return err;
}
-static cl_int _cl_map_mem(cl_mem mem, void **ptr, void **mem_ptr, size_t offset, size_t size)
+static cl_int _cl_map_mem(cl_mem mem, void *ptr, void **mem_ptr, size_t offset, size_t size)
{
cl_int slot = -1;
int err = CL_SUCCESS;
sub_offset = buffer->sub_offset;
}
- if (!(*ptr = cl_mem_map_gtt_unsync(mem))) {
- err = CL_MAP_FAILURE;
- goto error;
- }
- *ptr = (char*)(*ptr) + offset + sub_offset;
+ ptr = (char*)ptr + offset + sub_offset;
if(mem->flags & CL_MEM_USE_HOST_PTR) {
assert(mem->host_ptr);
//only calc ptr here, will do memcpy in enqueue
*mem_ptr = mem->host_ptr + offset + sub_offset;
} else {
- *mem_ptr = *ptr;
+ *mem_ptr = ptr;
}
/* Record the mapped address. */
if (!mem->mapped_ptr_sz) {
mem->mapped_ptr = (cl_mapped_ptr *)malloc(
sizeof(cl_mapped_ptr) * mem->mapped_ptr_sz);
if (!mem->mapped_ptr) {
- cl_mem_unmap_gtt(mem);
+ cl_mem_unmap_auto(mem);
err = CL_OUT_OF_HOST_MEMORY;
goto error;
}
cl_mapped_ptr *new_ptr = (cl_mapped_ptr *)malloc(
sizeof(cl_mapped_ptr) * mem->mapped_ptr_sz * 2);
if (!new_ptr) {
- cl_mem_unmap_gtt (mem);
+ cl_mem_unmap_auto(mem);
err = CL_OUT_OF_HOST_MEMORY;
goto error;
}
}
assert(slot != -1);
mem->mapped_ptr[slot].ptr = *mem_ptr;
- mem->mapped_ptr[slot].v_ptr = *ptr;
+ mem->mapped_ptr[slot].v_ptr = ptr;
mem->mapped_ptr[slot].size = size;
mem->map_ref++;
error:
goto error;
}
- err = _cl_map_mem(buffer, &ptr, &mem_ptr, offset, size);
- if (err != CL_SUCCESS)
- goto error;
-
TRY(cl_event_check_waitlist, num_events_in_wait_list, event_wait_list, event, buffer->ctx);
data = &no_wait_data;
data->offset = offset;
data->size = size;
data->ptr = ptr;
+ data->unsync_map = 1;
if(handle_events(command_queue, num_events_in_wait_list, event_wait_list,
event, data, CL_COMMAND_MAP_BUFFER) == CL_ENQUEUE_EXECUTE_IMM) {
+ data->unsync_map = 0;
err = cl_enqueue_handle(event ? *event : NULL, data);
+ if (err != CL_SUCCESS)
+ goto error;
+ ptr = data->ptr;
if(event) cl_event_set_status(*event, CL_COMPLETE);
+ } else {
+ if ((ptr = cl_mem_map_gtt_unsync(buffer)) == NULL) {
+ err = CL_MAP_FAILURE;
+ goto error;
+ }
}
+ err = _cl_map_mem(buffer, ptr, &mem_ptr, offset, size);
+ if (err != CL_SUCCESS)
+ goto error;
error:
if (errcode_ret)
goto error;
}
- if (!(ptr = cl_mem_map_gtt_unsync(mem))) {
- err = CL_MAP_FAILURE;
- goto error;
- }
-
size_t offset = image->bpp*origin[0] + image->row_pitch*origin[1] + image->slice_pitch*origin[2];
size_t size;
if(region[2] == 1) {
size += image->bpp * (origin[0] + region[0]);
}
- err = _cl_map_mem(mem, &ptr, &mem_ptr, offset, size);
- if (err != CL_SUCCESS)
- goto error;
-
TRY(cl_event_check_waitlist, num_events_in_wait_list, event_wait_list, event, mem->ctx);
data = &no_wait_data;
data->slice_pitch = *image_slice_pitch;
data->ptr = ptr;
data->offset = offset;
+ data->unsync_map = 1;
if(handle_events(command_queue, num_events_in_wait_list, event_wait_list,
event, data, CL_COMMAND_MAP_IMAGE) == CL_ENQUEUE_EXECUTE_IMM) {
+ data->unsync_map = 0;
err = cl_enqueue_handle(event ? *event : NULL, data);
+ if (err != CL_SUCCESS)
+ goto error;
+ ptr = data->ptr;
if(event) cl_event_set_status(*event, CL_COMPLETE);
+ } else {
+ if ((ptr = cl_mem_map_gtt_unsync(mem)) == NULL) {
+ err = CL_MAP_FAILURE;
+ goto error;
+ }
}
+ err = _cl_map_mem(mem, ptr, &mem_ptr, offset, size);
+ if (err != CL_SUCCESS)
+ goto error;
error:
if (errcode_ret)
mem->type == CL_MEM_SUBBUFFER_TYPE);
struct _cl_mem_buffer* buffer = (struct _cl_mem_buffer*)mem;
- //because using unsync map in clEnqueueMapBuffer, so force use map_gtt here
- if (!(ptr = cl_mem_map_gtt(mem))) {
+ if(data->unsync_map == 1)
+ //because using unsync map in clEnqueueMapBuffer, so force use map_gtt here
+ ptr = cl_mem_map_gtt(mem);
+ else
+ ptr = cl_mem_map_auto(mem);
+
+ if (ptr == NULL) {
err = CL_MAP_FAILURE;
goto error;
}
-
- ptr = (char*)ptr + data->offset + buffer->sub_offset;
- assert(data->ptr == ptr);
+ data->ptr = ptr;
if(mem->flags & CL_MEM_USE_HOST_PTR) {
assert(mem->host_ptr);
+ ptr = (char*)ptr + data->offset + buffer->sub_offset;
memcpy(mem->host_ptr + data->offset, ptr, data->size);
}
void *ptr = NULL;
CHECK_IMAGE(mem, image);
- if (!(ptr = cl_mem_map_gtt(mem))) {
+ if(data->unsync_map == 1)
+ //because using unsync map in clEnqueueMapBuffer, so force use map_gtt here
+ ptr = cl_mem_map_gtt(mem);
+ else
+ ptr = cl_mem_map_auto(mem);
+
+ if (ptr == NULL) {
err = CL_MAP_FAILURE;
goto error;
}
-
- assert(data->ptr == (char*)ptr + data->offset);
+ data->ptr = ptr;
if(mem->flags & CL_MEM_USE_HOST_PTR) {
assert(mem->host_ptr);
assert(v_ptr == mapped_ptr);
}
- cl_mem_unmap_gtt(memobj);
+ cl_mem_unmap_auto(memobj);
/* shrink the mapped slot. */
if (memobj->mapped_ptr_sz/2 > memobj->map_ref) {
#define CL_MEM_OBJECT_IMAGE2D 0x10F1
#define CL_MEM_OBJECT_IMAGE3D 0x10F2
+#define MAX_TILING_SIZE 128 * MB
+
static cl_mem_object_type
cl_get_mem_object_type(cl_mem mem)
{
sz = aligned_pitch * aligned_h * depth;
+ /* If sz is large than 128MB, map gtt may fail in some system.
+ Because there is no obviours performance drop, disable tiling. */
+ if(tiling != CL_NO_TILE && sz > MAX_TILING_SIZE) {
+ tiling = CL_NO_TILE;
+ aligned_pitch = w * bpp;
+ aligned_h = h;
+ sz = aligned_pitch * aligned_h * depth;
+ }
+
mem = cl_mem_allocate(CL_MEM_IMAGE_TYPE, ctx, flags, sz, tiling != CL_NO_TILE, &err);
if (mem == NULL || err != CL_SUCCESS)
goto error;
for(i=0; i<mem->mapped_ptr_sz; i++) {
if(mem->mapped_ptr[i].ptr != NULL) {
mem->map_ref--;
- cl_mem_unmap_gtt(mem);
+ cl_mem_unmap_auto(mem);
}
}
assert(mem->map_ref == 0);
{
cl_buffer_map_gtt(mem->bo);
assert(cl_buffer_get_virtual(mem->bo));
+ mem->mapped_gtt = 1;
return cl_buffer_get_virtual(mem->bo);
}
LOCAL cl_int
cl_mem_unmap_auto(cl_mem mem)
{
- if (IS_IMAGE(mem) && cl_mem_image(mem)->tiling != CL_NO_TILE)
+ if (mem->mapped_gtt == 1) {
cl_buffer_unmap_gtt(mem->bo);
+ mem->mapped_gtt = 0;
+ }
else
cl_buffer_unmap(mem->bo);
return CL_SUCCESS;