/*
* Copy the raster data from the completed thread to the caller's
* device (the main thread)
* Return 0 if OK, < 0 is the error code from the thread
*
* After swapping the pointers, start up the completed thread with the
* next band remaining to do (if any)
*/
static int
clist_get_band_from_thread(gx_device *dev, int band_needed)
{
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)dev;
gx_device_clist_reader *crdev = &cldev->reader;
int i, next_band, code = 0;
int thread_index = crdev->curr_render_thread;
clist_render_thread_control_t *thread = &(crdev->render_threads[thread_index]);
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)thread->cdev;
int band_height = crdev->page_info.band_params.BandHeight;
int band_count = cdev->nbands;
byte *tmp; /* for swapping data areas */
/* We expect that the thread needed will be the 'current' thread */
if (thread->band != band_needed) {
int band = band_needed;
/* Probably we went in the wrong direction, so let the threads */
/* all complete, then restart them in the opposite direction */
/* If the caller is 'bouncing around' we may end up back here, */
/* but that is a VERY rare case (we haven't seen it yet). */
for (i=0; i < crdev->num_render_threads; i++) {
clist_render_thread_control_t *thread = &(crdev->render_threads[i]);
if (thread->status == RENDER_THREAD_BUSY)
gx_semaphore_wait(thread->sema_this);
}
crdev->thread_lookahead_direction *= -1;
/* Loop creating the devices and semaphores for each thread, then start them */
for (i=0; (i < crdev->num_render_threads) && (band >= 0) && (band < band_count);
i++, band += crdev->thread_lookahead_direction) {
thread = &(crdev->render_threads[i]);
thread->band = -1; /* a value that won't match any valid band */
/* Start thread 'i' to do band */
if ((code = clist_start_render_thread(dev, i, band)) < 0)
break;
}
crdev->curr_render_thread = thread_index = 0;
thread = &(crdev->render_threads[0]);
}
/* Wait for this thread */
gx_semaphore_wait(thread->sema_this);
if (thread->status < 0)
return thread->status; /* FAIL */
/* Swap the data areas to avoid the copy */
tmp = cdev->data;
cdev->data = thread_cdev->data;
thread_cdev->data = tmp;
thread->status = RENDER_THREAD_IDLE; /* the data is no longer valid */
thread->band = -1;
/* Update the bounds for this band */
cdev->ymin = band_needed * band_height;
cdev->ymax = cdev->ymin + band_height;
if (cdev->ymax > dev->height)
cdev->ymax = dev->height;
/* If we are not at the final band, start up this thread with the next one to do */
next_band = band_needed + (crdev->num_render_threads * crdev->thread_lookahead_direction);
if (next_band >= 0 && next_band < band_count)
code = clist_start_render_thread(dev, thread_index, next_band);
/* bump the 'curr' to the next thread */
crdev->curr_render_thread = crdev->curr_render_thread == crdev->num_render_threads - 1 ?
0 : crdev->curr_render_thread + 1;
return code;
}
/*
* Copy the raster data from the completed thread to the caller's
* device (the main thread)
* Return 0 if OK, < 0 is the error code from the thread
*
* After swapping the pointers, start up the completed thread with the
* next band remaining to do (if any)
*/
static int
clist_get_band_from_thread(gx_device *dev, int band_needed, gx_process_page_options_t *options)
{
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)dev;
gx_device_clist_reader *crdev = &cldev->reader;
int i, code = 0;
int thread_index = crdev->curr_render_thread;
clist_render_thread_control_t *thread = &(crdev->render_threads[thread_index]);
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)thread->cdev;
int band_height = crdev->page_info.band_params.BandHeight;
int band_count = cdev->nbands;
byte *tmp; /* for swapping data areas */
/* We expect that the thread needed will be the 'current' thread */
if (thread->band != band_needed) {
int band = band_needed;
/* Probably we went in the wrong direction, so let the threads */
/* all complete, then restart them in the opposite direction */
/* If the caller is 'bouncing around' we may end up back here, */
/* but that is a VERY rare case (we haven't seen it yet). */
for (i=0; i < crdev->num_render_threads; i++) {
clist_render_thread_control_t *thread = &(crdev->render_threads[i]);
if (thread->status == THREAD_BUSY)
gx_semaphore_wait(thread->sema_this);
}
crdev->thread_lookahead_direction *= -1; /* reverse direction (but may be overruled below) */
if (band_needed == band_count-1)
crdev->thread_lookahead_direction = -1; /* assume backwards if we are asking for the last band */
if (band_needed == 0)
crdev->thread_lookahead_direction = 1; /* force forward if we are looking for band 0 */
/* Loop creating the devices and semaphores for each thread, then start them */
for (i=0; (i < crdev->num_render_threads) && (band >= 0) && (band < band_count);
i++, band += crdev->thread_lookahead_direction) {
thread = &(crdev->render_threads[i]);
thread->band = -1; /* a value that won't match any valid band */
/* Start thread 'i' to do band */
if ((code = clist_start_render_thread(dev, i, band)) < 0)
break;
}
crdev->next_band = i; /* may be < 0 or == band_count, but that is handled later */
crdev->curr_render_thread = thread_index = 0;
thread = &(crdev->render_threads[0]);
thread_cdev = (gx_device_clist_common *)thread->cdev;
}
/* Wait for this thread */
gx_semaphore_wait(thread->sema_this);
gp_thread_finish(thread->thread);
thread->thread = NULL;
if (thread->status == THREAD_ERROR)
return gs_error_unknownerror; /* FAIL */
if (options && options->output_fn) {
code = options->output_fn(options->arg, dev, thread->buffer);
if (code < 0)
return code;
}
/* Swap the data areas to avoid the copy */
tmp = cdev->data;
cdev->data = thread_cdev->data;
thread_cdev->data = tmp;
thread->status = THREAD_IDLE; /* the data is no longer valid */
thread->band = -1;
/* Update the bounds for this band */
cdev->ymin = band_needed * band_height;
cdev->ymax = cdev->ymin + band_height;
if (cdev->ymax > dev->height)
cdev->ymax = dev->height;
if (crdev->next_band >= 0 && crdev->next_band < band_count) {
code = clist_start_render_thread(dev, thread_index, crdev->next_band);
crdev->next_band += crdev->thread_lookahead_direction;
}
/* bump the 'curr' to the next thread */
crdev->curr_render_thread = crdev->curr_render_thread == crdev->num_render_threads - 1 ?
0 : crdev->curr_render_thread + 1;
return code;
}
/* Set up and start the render threads */
static int
clist_setup_render_threads(gx_device *dev, int y)
{
gx_device_printer *pdev = (gx_device_printer *)dev;
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)cldev;
gx_device_clist_reader *crdev = &cldev->reader;
gs_memory_t *mem = cdev->bandlist_memory;
gx_device *protodev;
gs_c_param_list paramlist;
int i, code, band;
int band_count = cdev->nbands;
char fmode[4];
crdev->num_render_threads = pdev->num_render_threads_requested;
if(gs_debug[':'] != 0)
dprintf1("%% %d rendering threads requested.\n", pdev->num_render_threads_requested);
if (crdev->num_render_threads > band_count)
crdev->num_render_threads = band_count; /* don't bother starting more threads than bands */
/* Allocate and initialize an array of thread control structures */
crdev->render_threads = (clist_render_thread_control_t *)
gs_alloc_byte_array(mem, crdev->num_render_threads,
sizeof(clist_render_thread_control_t), "clist_setup_render_threads" );
/* fallback to non-threaded if allocation fails */
if (crdev->render_threads == NULL) {
eprintf(" VMerror prevented threads from starting.\n");
return_error(gs_error_VMerror);
}
memset(crdev->render_threads, 0, crdev->num_render_threads *
sizeof(clist_render_thread_control_t));
crdev->main_thread_data = cdev->data; /* save data area */
/* Based on the line number requested, decide the order of band rendering */
/* Almost all devices go in increasing line order (except the bmp* devices ) */
crdev->thread_lookahead_direction = (y < (cdev->height - 1)) ? 1 : -1;
band = y / crdev->page_info.band_params.BandHeight;
/* Close the files so we can open them in multiple threads */
if ((code = cdev->page_info.io_procs->fclose(cdev->page_cfile, cdev->page_cfname, false)) < 0 ||
(code = cdev->page_info.io_procs->fclose(cdev->page_bfile, cdev->page_bfname, false)) < 0) {
gs_free_object(mem, crdev->render_threads, "clist_setup_render_threads");
crdev->render_threads = NULL;
eprintf("Closing clist files prevented threads from starting.\n");
return_error(gs_error_unknownerror); /* shouldn't happen */
}
cdev->page_cfile = cdev->page_bfile = NULL;
strcpy(fmode, "r"); /* read access for threads */
strncat(fmode, gp_fmode_binary_suffix, 1);
/* Find the prototype for this device (needed so we can copy from it) */
for (i=0; (protodev = (gx_device *)gs_getdevice(i)) != NULL; i++)
if (strcmp(protodev->dname, dev->dname) == 0)
break;
if (protodev == NULL) {
eprintf("Could not find prototype device. Rendering threads not started.\n");
return gs_error_rangecheck;
}
gs_c_param_list_write(¶mlist, mem);
if ((code = gs_getdeviceparams(dev, (gs_param_list *)¶mlist)) < 0) {
eprintf1("Error getting device params, code=%d. Rendering threads not started.\n", code);
return code;
}
/* Loop creating the devices and semaphores for each thread, then start them */
for (i=0; (i < crdev->num_render_threads) && (band >= 0) && (band < band_count);
i++, band += crdev->thread_lookahead_direction) {
gx_device *ndev;
gx_device_clist *ncldev;
gx_device_clist_common *ncdev;
clist_render_thread_control_t *thread = &(crdev->render_threads[i]);
/* Every thread will have a 'chunk allocator' to reduce the interaction
* with the 'base' allocator which has 'mutex' (locking) protection.
* This improves performance of the threads.
*/
if ((code = gs_memory_chunk_wrap(&(thread->memory), mem )) < 0) {
eprintf1("chunk_wrap returned error code: %d\n", code);
break;
}
thread->band = -1; /* a value that won't match any valid band */
if ((code = gs_copydevice((gx_device **) &ndev, protodev, thread->memory)) < 0) {
code = 0; /* even though we failed, no cleanup needed */
break;
}
ncldev = (gx_device_clist *)ndev;
ncdev = (gx_device_clist_common *)ndev;
gx_device_fill_in_procs(ndev);
((gx_device_printer *)ncdev)->buffer_memory = ncdev->memory =
ncdev->bandlist_memory = thread->memory;
gs_c_param_list_read(¶mlist);
ndev->PageCount = dev->PageCount; /* copy to prevent mismatch error */
if ((code = gs_putdeviceparams(ndev, (gs_param_list *)¶mlist)) < 0)
break;
ncdev->page_uses_transparency = cdev->page_uses_transparency;
/* gdev_prn_allocate_memory sets the clist for writing, creating new files.
* We need to unlink those files and open the main thread's files, then
* reset the clist state for reading/rendering
*/
if ((code = gdev_prn_allocate_memory(ndev, NULL, ndev->width, ndev->height)) < 0)
break;
thread->cdev = ndev;
/* close and unlink the temp files just created */
cdev->page_info.io_procs->fclose(ncdev->page_cfile, ncdev->page_cfname, true);
cdev->page_info.io_procs->fclose(ncdev->page_bfile, ncdev->page_bfname, true);
/* open the main thread's files for this thread */
if ((code=cdev->page_info.io_procs->fopen(cdev->page_cfname, fmode, &ncdev->page_cfile,
thread->memory, thread->memory, true)) < 0 ||
(code=cdev->page_info.io_procs->fopen(cdev->page_bfname, fmode, &ncdev->page_bfile,
thread->memory, thread->memory, false)) < 0)
break;
clist_render_init(ncldev); /* Initialize clist device for reading */
ncdev->page_bfile_end_pos = cdev->page_bfile_end_pos;
/* create the buf device for this thread, and allocate the semaphores */
if ((code = gdev_create_buf_device(cdev->buf_procs.create_buf_device,
&(thread->bdev), cdev->target,
band*crdev->page_band_height, NULL,
thread->memory, clist_get_band_complexity(dev,y)) < 0))
break;
if ((thread->sema_this = gx_semaphore_alloc(thread->memory)) == NULL ||
(thread->sema_group = gx_semaphore_alloc(thread->memory)) == NULL) {
code = gs_error_VMerror;
break;
}
/* Start thread 'i' to do band */
if ((code = clist_start_render_thread(dev, i, band)) < 0)
break;
}
gs_c_param_list_release(¶mlist);
/* If the code < 0, the last thread creation failed -- clean it up */
if (code < 0) {
/* the following relies on 'free' ignoring NULL pointers */
gx_semaphore_free(crdev->render_threads[i].sema_group);
gx_semaphore_free(crdev->render_threads[i].sema_this);
if (crdev->render_threads[i].bdev != NULL)
cdev->buf_procs.destroy_buf_device(crdev->render_threads[i].bdev);
if (crdev->render_threads[i].cdev != NULL) {
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)crdev->render_threads[i].cdev;
/* Close the file handles, but don't delete (unlink) the files */
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_bfile, thread_cdev->page_bfname, false);
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_cfile, thread_cdev->page_cfname, false);
thread_cdev->do_not_open_or_close_bandfiles = true; /* we already closed the files */
gdev_prn_free_memory((gx_device *)thread_cdev);
gs_free_object(crdev->render_threads[i].memory, thread_cdev,
"clist_setup_render_threads");
}
if (crdev->render_threads[i].memory != NULL)
gs_memory_chunk_release(crdev->render_threads[i].memory);
}
/* If we weren't able to create at least one thread, punt */
/* Although a single thread isn't any more efficient, the */
/* machinery still works, so that's OK. */
if (i == 0) {
if (crdev->render_threads[0].memory != NULL)
gs_memory_chunk_release(crdev->render_threads[0].memory);
gs_free_object(mem, crdev->render_threads, "clist_setup_render_threads");
crdev->render_threads = NULL;
/* restore the file pointers */
if (cdev->page_cfile == NULL) {
char fmode[4];
strcpy(fmode, "a+"); /* file already exists and we want to re-use it */
strncat(fmode, gp_fmode_binary_suffix, 1);
cdev->page_info.io_procs->fopen(cdev->page_cfname, fmode, &cdev->page_cfile,
mem, cdev->bandlist_memory, true);
cdev->page_info.io_procs->fseek(cdev->page_cfile, 0, SEEK_SET, cdev->page_cfname);
cdev->page_info.io_procs->fopen(cdev->page_bfname, fmode, &cdev->page_bfile,
mem, cdev->bandlist_memory, false);
cdev->page_info.io_procs->fseek(cdev->page_bfile, 0, SEEK_SET, cdev->page_bfname);
}
eprintf1("Rendering threads not started, code=%d.\n", code);
return_error(code);
}
crdev->num_render_threads = i;
crdev->curr_render_thread = 0;
if(gs_debug[':'] != 0)
dprintf1("%% Using %d rendering threads\n", i);
return 0;
}
/* Set up and start the render threads */
static int
clist_setup_render_threads(gx_device *dev, int y, gx_process_page_options_t *options)
{
gx_device_printer *pdev = (gx_device_printer *)dev;
gx_device_clist *cldev = (gx_device_clist *)dev;
gx_device_clist_common *cdev = (gx_device_clist_common *)cldev;
gx_device_clist_reader *crdev = &cldev->reader;
gs_memory_t *mem = cdev->bandlist_memory;
gs_memory_t *chunk_base_mem = mem->thread_safe_memory;
gs_memory_status_t mem_status;
int i, band;
int code = 0;
int band_count = cdev->nbands;
int band_height = crdev->page_info.band_params.BandHeight;
crdev->num_render_threads = pdev->num_render_threads_requested;
if(gs_debug[':'] != 0)
dmprintf1(mem, "%% %d rendering threads requested.\n", pdev->num_render_threads_requested);
if (crdev->num_render_threads > band_count)
crdev->num_render_threads = band_count; /* don't bother starting more threads than bands */
/* Allocate and initialize an array of thread control structures */
crdev->render_threads = (clist_render_thread_control_t *)
gs_alloc_byte_array(mem, crdev->num_render_threads,
sizeof(clist_render_thread_control_t), "clist_setup_render_threads" );
/* fallback to non-threaded if allocation fails */
if (crdev->render_threads == NULL) {
emprintf(mem, " VMerror prevented threads from starting.\n");
return_error(gs_error_VMerror);
}
memset(crdev->render_threads, 0, crdev->num_render_threads *
sizeof(clist_render_thread_control_t));
crdev->main_thread_data = cdev->data; /* save data area */
/* Based on the line number requested, decide the order of band rendering */
/* Almost all devices go in increasing line order (except the bmp* devices ) */
crdev->thread_lookahead_direction = (y < (cdev->height - 1)) ? 1 : -1;
band = y / band_height;
/* If the 'mem' is not thread safe, we need to wrap it in a locking memory */
gs_memory_status(chunk_base_mem, &mem_status);
if (mem_status.is_thread_safe == false) {
return_error(gs_error_VMerror);
}
/* If we don't have one large enough already, create an icc cache list */
if (crdev->num_render_threads > crdev->icc_cache_list_len) {
void *old = crdev->icc_cache_list;
crdev->icc_cache_list = gs_alloc_byte_array(mem->thread_safe_memory,
crdev->num_render_threads,
sizeof(void*), "clist_render_setup_threads");
if (crdev->icc_cache_list == NULL) {
crdev->icc_cache_list = NULL;
return_error(gs_error_VMerror);
}
if (crdev->icc_cache_list_len > 0)
memcpy(crdev->icc_cache_list, old, sizeof(void *)*crdev->icc_cache_list_len);
memset(&crdev->icc_cache_list[crdev->icc_cache_list_len], 0,
(crdev->num_render_threads - crdev->icc_cache_list_len) * sizeof(void *));
crdev->icc_cache_list_len = crdev->num_render_threads;
gs_free_object(mem, old, "clist_render_setup_threads");
}
/* Loop creating the devices and semaphores for each thread, then start them */
for (i=0; (i < crdev->num_render_threads) && (band >= 0) && (band < band_count);
i++, band += crdev->thread_lookahead_direction) {
gx_device *ndev;
clist_render_thread_control_t *thread = &(crdev->render_threads[i]);
ndev = setup_device_and_mem_for_thread(chunk_base_mem, dev, false, &crdev->icc_cache_list[i]);
if (ndev == NULL) {
code = gs_error_VMerror; /* set code to an error for cleanup after the loop */
break;
}
thread->cdev = ndev;
thread->memory = ndev->memory;
thread->band = -1; /* a value that won't match any valid band */
thread->options = options;
thread->buffer = NULL;
if (options && options->init_buffer_fn) {
code = options->init_buffer_fn(options->arg, dev, thread->memory, dev->width, band_height, &thread->buffer);
if (code < 0)
break;
}
/* create the buf device for this thread, and allocate the semaphores */
if ((code = gdev_create_buf_device(cdev->buf_procs.create_buf_device,
&(thread->bdev), ndev,
band*crdev->page_band_height, NULL,
thread->memory, &(crdev->color_usage_array[0])) < 0))
break;
if ((thread->sema_this = gx_semaphore_alloc(thread->memory)) == NULL ||
(thread->sema_group = gx_semaphore_alloc(thread->memory)) == NULL) {
code = gs_error_VMerror;
break;
}
/* Start thread 'i' to do band */
if ((code = clist_start_render_thread(dev, i, band)) < 0)
break;
}
/* If the code < 0, the last thread creation failed -- clean it up */
if (code < 0) {
band -= crdev->thread_lookahead_direction; /* update for 'next_band' usage */
/* the following relies on 'free' ignoring NULL pointers */
gx_semaphore_free(crdev->render_threads[i].sema_group);
gx_semaphore_free(crdev->render_threads[i].sema_this);
if (crdev->render_threads[i].bdev != NULL)
cdev->buf_procs.destroy_buf_device(crdev->render_threads[i].bdev);
if (crdev->render_threads[i].cdev != NULL) {
gx_device_clist_common *thread_cdev = (gx_device_clist_common *)crdev->render_threads[i].cdev;
/* Close the file handles, but don't delete (unlink) the files */
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_info.bfile, thread_cdev->page_info.bfname, false);
thread_cdev->page_info.io_procs->fclose(thread_cdev->page_info.cfile, thread_cdev->page_info.cfname, false);
thread_cdev->do_not_open_or_close_bandfiles = true; /* we already closed the files */
gdev_prn_free_memory((gx_device *)thread_cdev);
gs_free_object(crdev->render_threads[i].memory, thread_cdev,
"clist_setup_render_threads");
}
if (crdev->render_threads[i].buffer != NULL && options && options->free_buffer_fn != NULL) {
options->free_buffer_fn(options->arg, dev, crdev->render_threads[i].memory, crdev->render_threads[i].buffer);
crdev->render_threads[i].buffer = NULL;
}
if (crdev->render_threads[i].memory != NULL) {
gs_memory_chunk_release(crdev->render_threads[i].memory);
crdev->render_threads[i].memory = NULL;
}
}
/* If we weren't able to create at least one thread, punt */
/* Although a single thread isn't any more efficient, the */
/* machinery still works, so that's OK. */
if (i == 0) {
if (crdev->render_threads[0].memory != NULL) {
gs_memory_chunk_release(crdev->render_threads[0].memory);
/* free up the locking wrapper if we allocated one */
if (chunk_base_mem != mem) {
gs_memory_locked_release((gs_memory_locked_t *)chunk_base_mem);
gs_free_object(mem, chunk_base_mem, "clist_setup_render_threads(locked allocator)");
}
}
gs_free_object(mem, crdev->render_threads, "clist_setup_render_threads");
crdev->render_threads = NULL;
/* restore the file pointers */
if (cdev->page_info.cfile == NULL) {
char fmode[4];
strcpy(fmode, "a+"); /* file already exists and we want to re-use it */
strncat(fmode, gp_fmode_binary_suffix, 1);
cdev->page_info.io_procs->fopen(cdev->page_info.cfname, fmode, &cdev->page_info.cfile,
mem, cdev->bandlist_memory, true);
cdev->page_info.io_procs->fseek(cdev->page_info.cfile, 0, SEEK_SET, cdev->page_info.cfname);
cdev->page_info.io_procs->fopen(cdev->page_info.bfname, fmode, &cdev->page_info.bfile,
mem, cdev->bandlist_memory, false);
cdev->page_info.io_procs->fseek(cdev->page_info.bfile, 0, SEEK_SET, cdev->page_info.bfname);
}
emprintf1(mem, "Rendering threads not started, code=%d.\n", code);
return_error(code);
}
crdev->num_render_threads = i;
crdev->curr_render_thread = 0;
crdev->next_band = band;
if(gs_debug[':'] != 0)
dmprintf1(mem, "%% Using %d rendering threads\n", i);
return 0;
}
