Skip to content
Snippets Groups Projects
Commit 3d081bee authored by EXT Jean-Matthieu Etancelin's avatar EXT Jean-Matthieu Etancelin
Browse files

Improve gpyfft import when using a non OpenCL machine (creates a fake import)

parent 2cfb1d6a
No related branches found
No related tags found
1 merge request!16MPI operators
Hide whitespace changes
Inline Side-by-side
hysop/backend/device/opencl/opencl_fft.py
+ 91
− 84
View file @ 3d081bee
import warnings
import numpy as np
from gpyfft.fft import FFT, gfft, GFFT
try:
from gpyfft.fft import FFT, gfft, GFFT
except ImportError as e:
class FFT():
def __init__(self):
assert False, "Du to gpyfft import error ({}), this class is useless".format(e)
gfft, GFFT = None, None
print e
print "Some functionnalities may not work. It seems that hysop is called from non OpenCL machine."
from hysop import vprint
from hysop.tools.types import first_not_None
from hysop.tools.warning import HysopWarning
......@@ -11,9 +18,10 @@ from hysop.tools.numpywrappers import npw
from hysop.backend.device.opencl import cl, clArray
from hysop.backend.device.codegen.base.variables import dtype_to_ctype
class OpenClFFT(FFT):
def __init__(self, context, queue, in_array,
def __init__(self, context, queue, in_array,
out_array=None, axes=None,
fast_math=False, real=False,
keep_buffer_offset=False):
......@@ -28,9 +36,9 @@ class OpenClFFT(FFT):
axes = np.argsort(in_array.strides)
else:
axes = np.asarray(axes)
t_strides_in, t_distance_in, t_batchsize_in, t_shape, axes_transform = \
self.calculate_transform_strides(axes, in_array)
self.calculate_transform_strides(axes, in_array)
if (out_array is not None):
t_inplace = False
......@@ -44,7 +52,7 @@ class OpenClFFT(FFT):
assert (out_array.offset + out_array.nbytes) < in_array.offset
else:
t_inplace = True
msg='error finding transform axis (consider setting axes argument)'
msg = 'error finding transform axis (consider setting axes argument)'
assert np.all(axes_transform == axes_transform_out), msg
else:
out_array = in_array
......@@ -57,29 +65,29 @@ class OpenClFFT(FFT):
precision = gfft.CLFFT_DOUBLE
if in_array.dtype in (np.float32, np.float64):
layout_in = gfft.CLFFT_REAL
layout_in = gfft.CLFFT_REAL
layout_out = gfft.CLFFT_HERMITIAN_INTERLEAVED
expected_out_shape = list(in_array.shape)
expected_out_shape[axes_transform[0]] = \
expected_out_shape[axes_transform[0]]//2 + 1
msg='output array shape {} does not match expected shape: {}'
msg=msg.format(out_array.shape, expected_out_shape)
expected_out_shape[axes_transform[0]]//2 + 1
msg = 'output array shape {} does not match expected shape: {}'
msg = msg.format(out_array.shape, expected_out_shape)
assert out_array.shape == tuple(expected_out_shape), msg
elif in_array.dtype in (np.complex64, np.complex128):
if not real:
layout_in = gfft.CLFFT_COMPLEX_INTERLEAVED
layout_in = gfft.CLFFT_COMPLEX_INTERLEAVED
layout_out = gfft.CLFFT_COMPLEX_INTERLEAVED
else:
layout_in = gfft.CLFFT_HERMITIAN_INTERLEAVED
layout_in = gfft.CLFFT_HERMITIAN_INTERLEAVED
layout_out = gfft.CLFFT_REAL
t_shape = t_shape_out
if t_inplace and ((layout_in is gfft.CLFFT_REAL) or
(layout_out is gfft.CLFFT_REAL)):
assert ((in_array.strides[axes_transform[0]] == in_array.dtype.itemsize) and \
assert ((in_array.strides[axes_transform[0]] == in_array.dtype.itemsize) and
(out_array.strides[axes_transform[0]] == out_array.dtype.itemsize)), \
'inline real transforms need stride 1 for first transform axis'
'inline real transforms need stride 1 for first transform axis'
self.t_shape = t_shape
self.batchsize = t_batchsize_in
......@@ -93,24 +101,24 @@ class OpenClFFT(FFT):
plan.batch_size = self.batchsize
plan.precision = precision
plan.layouts = (layout_in, layout_out)
assert not keep_buffer_offset
(in_data, out_data) = self.set_offset_callbacks(plan, in_array, out_array,
layout_in, layout_out,
keep_buffer_offset)
(in_data, out_data) = self.set_offset_callbacks(plan, in_array, out_array,
layout_in, layout_out,
keep_buffer_offset)
self.plan = plan
self.in_array = in_array
self.in_array = in_array
self.out_array = out_array
self.in_data = in_data
self.out_data = out_data
self.temp_buffer = None
self._baked = False
self._allocated = False
self._baked = False
self._allocated = False
def set_offset_callbacks(self, plan, in_array, out_array, layout_in, layout_out,
keep_buffer_offset):
keep_buffer_offset):
try:
if keep_buffer_offset:
raise clArray.ArrayHasOffsetError
......@@ -131,38 +139,38 @@ class OpenClFFT(FFT):
post, output_buffer_offset = self.post_offset_callback(out_array, layout_out)
plan.set_callback('post_callback', post, 'post', user_data=None)
self.input_buffer_offset = input_buffer_offset
self.input_buffer_offset = input_buffer_offset
self.output_buffer_offset = output_buffer_offset
return (in_data, out_data)
def bake(self):
if self._baked:
msg='Plan was already baked.'
msg = 'Plan was already baked.'
raise RuntimeError(msg)
msg = 'Baking {}[precision={}, shape={}, inplace={}, layout_in={}, layout_out={}]'.format(
self.__class__.__name__,
self.precision, self.t_shape, self.t_inplace,
self.layout_in, self.layout_out)
self.__class__.__name__,
self.precision, self.t_shape, self.t_inplace,
self.layout_in, self.layout_out)
self.plan.bake(self.queue)
self._baked = True
return self
def allocate(self, buf=None):
if self._allocated:
msg='Plan was already allocated.'
msg = 'Plan was already allocated.'
raise RuntimeError(msg)
size = self.plan.temp_array_size
if (size>0):
if (size > 0):
if (buf is None):
msg='Allocating temporary buffer of size {} for clFFT::{}.'
msg=msg.format(bytes2str(size), id(self))
msg = 'Allocating temporary buffer of size {} for clFFT::{}.'
msg = msg.format(bytes2str(size), id(self))
warnings.warn(msg, HysopWarning)
buf = cl.Buffer(self.context, cl.mem_flags.READ_WRITE, size=size)
self.temp_buffer = buf
elif (buf.size != size):
msg='Buffer does not match required size: {} != {}'
msg=msg.format(buf.size, size)
msg = 'Buffer does not match required size: {} != {}'
msg = msg.format(buf.size, size)
raise ValueError(msg)
else:
self.temp_buffer = buf.data
......@@ -174,9 +182,9 @@ class OpenClFFT(FFT):
def enqueue(self, queue=None, wait_for_events=None, direction_forward=True):
"""
Enqueue transform with array base_data.
/!\ Do not forget to offset input and output by array.offset
within custom user callbacks, only base_data is passed
to ensure OpenCL pointers alignment of kernel arguments.
/!\ Do not forget to offset input and output by array.offset
within custom user callbacks, only base_data is passed
to ensure OpenCL pointers alignment of kernel arguments.
See self.set_offset_callbacks().
"""
self._assert_ready()
......@@ -184,21 +192,21 @@ class OpenClFFT(FFT):
queue = first_not_None(queue, self.queue)
if self.t_inplace:
events = self.plan.enqueue_transform((queue,),
(in_data,),
direction_forward=direction_forward,
temp_buffer=self.temp_buffer,
wait_for_events=wait_for_events)
events = self.plan.enqueue_transform((queue,),
(in_data,),
direction_forward=direction_forward,
temp_buffer=self.temp_buffer,
wait_for_events=wait_for_events)
else:
events = self.plan.enqueue_transform((queue,),
(in_data,), (out_data),
direction_forward=direction_forward,
temp_buffer=self.temp_buffer,
wait_for_events=wait_for_events)
events = self.plan.enqueue_transform((queue,),
(in_data,), (out_data),
direction_forward=direction_forward,
temp_buffer=self.temp_buffer,
wait_for_events=wait_for_events)
return events
def enqueue_arrays(self, *args, **kwds):
msg='Enqueue arrays is not supported.'
msg = 'Enqueue arrays is not supported.'
raise NotImplementedError(msg)
@property
......@@ -212,94 +220,94 @@ class OpenClFFT(FFT):
def _assert_ready(self):
if __debug__ and not self.ready:
msg='Plan is not ready:'
msg+='\n *baked: {}'
msg+='\n *allocated: {}'
msg+='\n'
msg=msg.format(self._baked, self._allocated)
msg = 'Plan is not ready:'
msg += '\n *baked: {}'
msg += '\n *allocated: {}'
msg += '\n'
msg = msg.format(self._baked, self._allocated)
raise RuntimeError(msg)
@classmethod
def check_dtype(cls, dtype, layout):
if layout in (gfft.CLFFT_HERMITIAN_INTERLEAVED, gfft.CLFFT_COMPLEX_INTERLEAVED):
if not is_complex(dtype):
msg='Layout is {} but got array with dtype {}.'
msg=msg.format(layout, dtype)
msg = 'Layout is {} but got array with dtype {}.'
msg = msg.format(layout, dtype)
raise RuntimeError(msg)
elif layout in (gfft.CLFFT_REAL,):
if not is_fp(dtype):
msg='Layout is CLFFT_REAL but got array with dtype {}.'
msg=msg.format(dtype)
msg = 'Layout is CLFFT_REAL but got array with dtype {}.'
msg = msg.format(dtype)
raise RuntimeError(msg)
else:
msg='Unsupported data layout {}.'
msg=msg.format(layout)
msg = 'Unsupported data layout {}.'
msg = msg.format(layout)
raise NotImplementedError(msg)
def pre_offset_callback(self, in_array, layout_in):
dtype = in_array.dtype
fp = dtype_to_ctype(dtype)
self.check_dtype(dtype, layout_in)
if (in_array.offset % dtype.itemsize) != 0:
msg='Unaligned array offset.'
msg = 'Unaligned array offset.'
raise RuntimeError(msg)
base_offset = (in_array.offset // dtype.itemsize)
callback = \
'''
'''
{fp} pre_callback(__global void* input,
const uint offset,
__global void* userdata) {{
__global {fp}* in = (__global {fp}*) input;
__global {fp}* in = (__global {fp}*) input;
return in[{base_offset}uL+offset];
}}
'''.format(fp=fp, base_offset=base_offset)
input_buffer_offset = '{}uL'.format(base_offset)
return callback, input_buffer_offset
def post_offset_callback(self, out_array, layout_out):
dtype = out_array.dtype
self.check_dtype(dtype, layout_out)
fp = dtype_to_ctype(dtype)
if (out_array.offset % dtype.itemsize) != 0:
msg='Unaligned array offset.'
msg = 'Unaligned array offset.'
raise RuntimeError(msg)
base_offset = (out_array.offset // dtype.itemsize)
callback = \
'''
'''
void post_callback(__global void* output,
const uint offset,
__global void* userdata,
const {fp} fftoutput) {{
__global {fp}* out = (__global {fp}*) output;
__global {fp}* out = (__global {fp}*) output;
out[{base_offset}uL+offset] = fftoutput;
}}
'''.format(fp=fp, base_offset=base_offset)
output_buffer_offset = '{}uL'.format(base_offset)
return callback, output_buffer_offset
@classmethod
def allocate_plans(cls, operator, plans):
tmp_size = max(plan.required_buffer_size for plan in plans)
msg='Allocating an additional {} temporary buffer for clFFT in operator {}.'.format(
bytes2str(tmp_size), operator.name)
msg = 'Allocating an additional {} temporary buffer for clFFT in operator {}.'.format(
bytes2str(tmp_size), operator.name)
if (tmp_size>0):
if (tmp_size > 0):
vprint(msg)
tmp_buffer = operator.backend.empty(shape=(tmp_size), dtype=npw.uint8)
for plan in plans:
if (plan.required_buffer_size > tmp_buffer.nbytes):
msg='\nFATAL ERROR: Failed to allocate temporary buffer for clFFT.'
msg+='\n => clFFT expected {} bytes but only {} bytes have been allocated.\n'
msg=msg.format(plan.required_buffer_size, tmp_buffer.nbytes)
msg = '\nFATAL ERROR: Failed to allocate temporary buffer for clFFT.'
msg += '\n => clFFT expected {} bytes but only {} bytes have been allocated.\n'
msg = msg.format(plan.required_buffer_size, tmp_buffer.nbytes)
raise RuntimeError(msg)
elif (plan.required_buffer_size>0):
elif (plan.required_buffer_size > 0):
buf = tmp_buffer[:plan.required_buffer_size]
plan.allocate(buf=buf)
else:
......@@ -310,4 +318,3 @@ class OpenClFFT(FFT):
plan.allocate()
tmp_buffer = None
return tmp_buffer
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment