bool
check(misc::runner const & i_runner, host::generic_program i_program)
{
chrono::steady_clock::time_point tp = chrono::steady_clock::now();
host::buffer<pfm::int_> bufWrite(i_runner.m_context, item_count);
typedef host::buffer<pfm::int_>::const_iterator iterator;
i_runner.m_queue(
run_kernel(i_program,
fill_index(bufWrite),
item_count));
i_runner.m_queue(
run_kernel(i_program,
twice(bufWrite),
item_count));
auto future =
i_runner.m_queue(
bufWrite.with_range(
[](iterator i_begin, iterator i_end) {
return std::accumulate(i_begin, i_end, 0);
}));
std::future_status result = future.wait_until(tp + chrono::seconds(5));
assert(result == std::future_status::ready);
assert(future.get() == arith(2, item_count));
return true;
}
void stress(misc::runner const & i_runner,
host::program<decltype(prog)> i_program)
{
host::context const& context = i_runner.m_context;
host::queue & queue = i_runner.m_queue;
host::buffer<pfm::int_> bufWrite(context, item_count);
host::buffer<pfm::int_> bufDiff(context, item_count);
queue(host::run_kernel(i_program, fill_index(bufWrite), item_count));
queue(host::run_kernel(i_program, fill_index(bufDiff), item_count));
for (int i = 0; i < 100; ++i) {
std::thread th(
[&] () {
queue(host::run_kernel(i_program, add(bufWrite, bufDiff), item_count));
queue(host::run_kernel(i_program, subtract(bufWrite, bufDiff), item_count));
}
);
th.detach();
}
typedef decltype(bufWrite)::iterator iterator;
for (int i = 0; i < 20; ++i) {
auto future2 =
queue(bufWrite.with_range(
[](iterator i_begin, iterator i_end) {
return std::accumulate(i_begin, i_end, 0);
}));
cl_int retval = future2.get();
//std::cout << retval << std::endl;
assert( retval % (item_count * (item_count - 1) / 2) == 0);
}
}
int main(int argc, char *argv[]) {
const int numWrites = 4, numReads = 10, numBufs = 3, maxN = 20;
int i,j;
data_t datum;
bool_t shouldReset;
bool_t datumOut;
buf_t **bufs = (buf_t **)malloc(numBufs * sizeof(buf_t *));
for (i=0; i<numBufs; i++)
bufs[i] = bufAlloc(maxN);
for (i=0; i<numWrites; i++) {
for (j=0; j<numBufs; j++)
bufWrite(bufs[j], randomIdx(bufs[j]), (data_t)__VERIFIER_nondet_int());
}
for (i=0; i<numReads; i++) {
for (j=0; j<numBufs; j++) {
datum = (data_t) __VERIFIER_nondet_int();
shouldReset = __VERIFIER_nondet_int();
datumOut = (data_t)0;
if (shouldReset)
bufReset(bufs[j], datum);
else
datumOut = bufRead(bufs[j], randomIdx(bufs[j]));
}
}
return 1;
}
bool
check(misc::runner const & i_runner, host::generic_program i_program)
{
chrono::steady_clock::time_point tp = chrono::steady_clock::now();
host::buffer<pfm::int_> bufWrite(i_runner.m_context, item_count);
typedef host::buffer<pfm::int_>::const_iterator iterator;
// kernel内で使用できる事の確認
i_runner.m_queue(
run_kernel(
i_program,
fill_index(bufWrite),
item_count));
auto future =
i_runner.m_queue(
bufWrite.with_range(
[](iterator i_begin, iterator i_end){
return std::accumulate(i_begin, i_end, 0);
}));
std::future_status result =
future.wait_until(tp + chrono::seconds(5));
assert(result == std::future_status::ready);
assert(future.get() == arith(2, item_count));
// ホストから呼べない事の確認
try {
int const a = 1; //gcc-4.7.2 twice(1)と書くと内部エラー
i_runner.m_queue(
host::run_kernel(
i_program,
twice(a),
1)
);
assert(false);
}
catch (cl::Error err) {
assert(err.err() == CL_INVALID_KERNEL_NAME);
}
return true;
}
static void
tunnelDispatch(TunnelPtr tunnel)
{
if(circularBufferEmpty(&tunnel->buf1)) {
if(tunnel->buf1.buf &&
!(tunnel->flags & (TUNNEL_READER1 | TUNNEL_WRITER2))) {
dispose_chunk(tunnel->buf1.buf);
tunnel->buf1.buf = NULL;
tunnel->buf1.head = tunnel->buf1.tail = 0;
}
}
if(circularBufferEmpty(&tunnel->buf2)) {
if(tunnel->buf2.buf &&
!(tunnel->flags & (TUNNEL_READER2 | TUNNEL_WRITER1))) {
dispose_chunk(tunnel->buf2.buf);
tunnel->buf2.buf = NULL;
tunnel->buf2.head = tunnel->buf2.tail = 0;
}
}
if(tunnel->fd1 >= 0) {
if(!(tunnel->flags & (TUNNEL_READER1 | TUNNEL_EOF1)) &&
!circularBufferFull(&tunnel->buf1)) {
tunnel->flags |= TUNNEL_READER1;
bufRead(tunnel->fd1, &tunnel->buf1, tunnelRead1Handler, tunnel);
}
if(!(tunnel->flags & (TUNNEL_WRITER1 | TUNNEL_EPIPE1)) &&
!circularBufferEmpty(&tunnel->buf2)) {
tunnel->flags |= TUNNEL_WRITER1;
/* There's no IO_NOTNOW in bufWrite, so it might close the
file descriptor straight away. Wait until we're
rescheduled. */
bufWrite(tunnel->fd1, &tunnel->buf2, tunnelWrite1Handler, tunnel);
return;
}
if(tunnel->fd2 < 0 || (tunnel->flags & TUNNEL_EOF2)) {
if(!(tunnel->flags & TUNNEL_EPIPE1))
shutdown(tunnel->fd1, 1);
tunnel->flags |= TUNNEL_EPIPE1;
} else if(tunnel->fd1 < 0 || (tunnel->flags & TUNNEL_EPIPE2)) {
if(!(tunnel->flags & TUNNEL_EOF1))
shutdown(tunnel->fd1, 0);
tunnel->flags |= TUNNEL_EOF1;
}
if((tunnel->flags & TUNNEL_EOF1) && (tunnel->flags & TUNNEL_EPIPE1)) {
if(!(tunnel->flags & (TUNNEL_READER1 | TUNNEL_WRITER1))) {
CLOSE(tunnel->fd1);
tunnel->fd1 = -1;
}
}
}
if(tunnel->fd2 >= 0) {
if(!(tunnel->flags & (TUNNEL_READER2 | TUNNEL_EOF2)) &&
!circularBufferFull(&tunnel->buf2)) {
tunnel->flags |= TUNNEL_READER2;
bufRead(tunnel->fd2, &tunnel->buf2, tunnelRead2Handler, tunnel);
}
if(!(tunnel->flags & (TUNNEL_WRITER2 | TUNNEL_EPIPE2)) &&
!circularBufferEmpty(&tunnel->buf1)) {
tunnel->flags |= TUNNEL_WRITER2;
bufWrite(tunnel->fd2, &tunnel->buf1, tunnelWrite2Handler, tunnel);
return;
}
if(tunnel->fd1 < 0 || (tunnel->flags & TUNNEL_EOF1)) {
if(!(tunnel->flags & TUNNEL_EPIPE2))
shutdown(tunnel->fd2, 1);
tunnel->flags |= TUNNEL_EPIPE2;
} else if(tunnel->fd1 < 0 || (tunnel->flags & TUNNEL_EPIPE1)) {
if(!(tunnel->flags & TUNNEL_EOF2))
shutdown(tunnel->fd2, 0);
tunnel->flags |= TUNNEL_EOF2;
}
if((tunnel->flags & TUNNEL_EOF2) && (tunnel->flags & TUNNEL_EPIPE2)) {
if(!(tunnel->flags & (TUNNEL_READER2 | TUNNEL_WRITER2))) {
CLOSE(tunnel->fd2);
tunnel->fd2 = -1;
}
}
}
if(tunnel->fd1 < 0 && tunnel->fd2 < 0)
destroyTunnel(tunnel);
else
assert(tunnel->flags & (TUNNEL_READER1 | TUNNEL_WRITER1 |
TUNNEL_READER2 | TUNNEL_WRITER2));
}
int map_image_header(char *buf, Image_subheader *header) {
int i = 0;
bufWrite_s(header->data_type, buf, &i);
bufWrite_s(header->num_dimensions, buf, &i);
bufWrite_s(header->x_dimension, buf, &i);
bufWrite_s(header->y_dimension, buf, &i);
bufWrite_s(header->z_dimension, buf, &i);
bufWrite_f(header->z_offset, buf, &i);
bufWrite_f(header->x_offset, buf, &i);
bufWrite_f(header->y_offset, buf, &i);
bufWrite_f(header->recon_zoom, buf, &i);
bufWrite_f(header->scale_factor, buf, &i);
bufWrite_s(header->image_min, buf, &i);
bufWrite_s(header->image_max, buf, &i);
bufWrite_f(header->x_pixel_size, buf, &i);
bufWrite_f(header->y_pixel_size, buf, &i);
bufWrite_f(header->z_pixel_size, buf, &i);
bufWrite_u(header->frame_duration, buf, &i);
bufWrite_u(header->frame_start_time, buf, &i);
bufWrite_s(header->filter_code, buf, &i);
bufWrite_f(header->x_resolution, buf, &i);
bufWrite_f(header->y_resolution, buf, &i);
bufWrite_f(header->z_resolution, buf, &i);
bufWrite_f(header->num_r_elements, buf, &i);
bufWrite_f(header->num_angles, buf, &i);
bufWrite_f(header->z_rotation_angle, buf, &i);
bufWrite_f(header->decay_corr_fctr, buf, &i);
bufWrite_i(header->processing_code, buf, &i);
bufWrite_u(header->gate_duration, buf, &i);
bufWrite_i(header->r_wave_offset, buf, &i);
bufWrite_i(header->num_accepted_beats, buf, &i);
bufWrite_f(header->filter_cutoff_frequency, buf, &i);
bufWrite_f(header->filter_resolution, buf, &i);
bufWrite_f(header->filter_ramp_slope, buf, &i);
bufWrite_s(header->filter_order, buf, &i);
bufWrite_f(header->filter_scatter_fraction, buf, &i);
bufWrite_f(header->filter_scatter_slope, buf, &i);
bufWrite(header->annotation, buf, &i, 40);
bufWrite_f(header->mt_1_1, buf, &i);
bufWrite_f(header->mt_1_2, buf, &i);
bufWrite_f(header->mt_1_3, buf, &i);
bufWrite_f(header->mt_2_1, buf, &i);
bufWrite_f(header->mt_2_2, buf, &i);
bufWrite_f(header->mt_2_3, buf, &i);
bufWrite_f(header->mt_3_1, buf, &i);
bufWrite_f(header->mt_3_2, buf, &i);
bufWrite_f(header->mt_3_3, buf, &i);
bufWrite_f(header->rfilter_cutoff, buf, &i);
bufWrite_f(header->rfilter_resolution, buf, &i);
bufWrite_s(header->rfilter_code, buf, &i);
bufWrite_s(header->rfilter_order, buf, &i);
bufWrite_f(header->zfilter_cutoff, buf, &i);
bufWrite_f(header->zfilter_resolution, buf, &i);
bufWrite_s(header->zfilter_code, buf, &i);
bufWrite_s(header->zfilter_order, buf, &i);
bufWrite_f(header->mt_1_4, buf, &i);
bufWrite_f(header->mt_2_4, buf, &i);
bufWrite_f(header->mt_3_4, buf, &i);
bufWrite_s(header->scatter_type, buf, &i);
bufWrite_s(header->recon_type, buf, &i);
bufWrite_s(header->recon_views, buf, &i);
return 1;
}
int map_main_header(char *bufr,Main_header *header) {
int i = 0, j = 0;
char mn[20];
/* set magic number */
sprintf(mn,"%s%d%s", magicNumber,header->sw_version,
dstypecode[header->file_type]);
bufWrite(mn, bufr, &i, 14);
/* copy buffer into struct */
bufWrite(header->original_file_name, bufr, &i, NameLen);
bufWrite_s(header->sw_version, bufr, &i);
bufWrite_s(header->system_type, bufr, &i);
bufWrite_s(header->file_type, bufr, &i);
bufWrite(header->serial_number, bufr, &i, 10);
bufWrite_u(header->scan_start_time, bufr, &i);
bufWrite(header->isotope_code, bufr, &i, 8);
bufWrite_f(header->isotope_halflife, bufr, &i);
bufWrite(header->radiopharmaceutical, bufr, &i, NameLen);
bufWrite_f(header->gantry_tilt, bufr, &i);
bufWrite_f(header->gantry_rotation, bufr, &i);
bufWrite_f(header->bed_elevation, bufr, &i);
bufWrite_f(header->intrinsic_tilt, bufr, &i);
bufWrite_s(header->wobble_speed, bufr, &i);
bufWrite_s(header->transm_source_type, bufr, &i);
bufWrite_f(header->distance_scanned, bufr, &i);
bufWrite_f(header->transaxial_fov, bufr, &i);
bufWrite_s(header->angular_compression, bufr, &i);
bufWrite_s(header->coin_samp_mode, bufr, &i);
bufWrite_s(header->axial_samp_mode, bufr, &i);
bufWrite_f(header->calibration_factor, bufr, &i);
bufWrite_s(header->calibration_units, bufr, &i);
bufWrite_s(header->calibration_units_label, bufr, &i);
bufWrite_s(header->compression_code, bufr, &i);
bufWrite(header->study_name, bufr, &i, 12);
bufWrite(header->patient_id, bufr, &i, IDLen);
bufWrite(header->patient_name, bufr, &i, NameLen);
bufWrite(header->patient_sex, bufr, &i, 1);
bufWrite(header->patient_dexterity, bufr, &i, 1);
bufWrite_f(header->patient_age, bufr, &i);
bufWrite_f(header->patient_height, bufr, &i);
bufWrite_f(header->patient_weight, bufr, &i);
bufWrite_i(header->patient_birth_date, bufr, &i);
bufWrite(header->physician_name, bufr, &i, NameLen);
bufWrite(header->operator_name, bufr, &i, NameLen);
bufWrite(header->study_description, bufr, &i, NameLen);
bufWrite_s(header->acquisition_type, bufr, &i);
bufWrite_s(header->patient_orientation, bufr, &i);
bufWrite(header->facility_name, bufr, &i, 20);
bufWrite_s(header->num_planes, bufr, &i);
bufWrite_s(header->num_frames, bufr, &i);
bufWrite_s(header->num_gates, bufr, &i);
bufWrite_s(header->num_bed_pos, bufr, &i);
bufWrite_f(header->init_bed_position, bufr, &i);
for(j = 0; j < 15; j++)
bufWrite_f(header->bed_offset[j], bufr, &i);
bufWrite_f(header->plane_separation, bufr, &i);
bufWrite_s(header->lwr_sctr_thres, bufr, &i);
bufWrite_s(header->lwr_true_thres, bufr, &i);
bufWrite_s(header->upr_true_thres, bufr, &i);
bufWrite(header->user_process_code, bufr, &i, 10);
bufWrite_s(header->acquisition_mode, bufr, &i);
bufWrite_f(header->bin_size, bufr, &i);
bufWrite_f(header->branching_fraction, bufr, &i);
bufWrite_u(header->dose_start_time, bufr, &i);
bufWrite_f(header->dosage, bufr, &i);
bufWrite_f(header->well_counter_factor, bufr, &i);
bufWrite(header->data_units, bufr, &i, 32);
bufWrite_s(header->septa_state, bufr, &i);
return 1;
}
