void make_loop(int n, int* last_pipe, char* grammar) { /* last_pipe[0] = input of the recently created pipe * * last_pipe[1] = output of the first pipe */ pid_t pid; if (n == 1) { prepare_input(last_pipe); prepare_output(last_pipe); close_pipe(last_pipe); return; } int next_pipe[2]; create_pipe(next_pipe); switch (pid = fork()) { case -1: syserr("Error in fork()\n"); case 0: prepare_input(last_pipe); close_pipe(last_pipe); prepare_output(next_pipe); close_pipe(next_pipe); execl("./worker", "./worker", grammar, NULL); syserr("Error in execl()\n"); default: last_pipe[0] = next_pipe[0]; make_loop(n - 1, last_pipe, grammar); return; } }
/*===========================================================================* * output_done * *===========================================================================*/ static void output_done() { /* Previous chunk of printing is finished. Continue if OK and more. * Otherwise, reply to caller (FS). */ int status; if (!writing) return; /* probably leftover interrupt */ if (done_status != OK) { /* printer error occurred */ status = EIO; if ((done_status & ON_LINE) == 0) { printf("Printer is not on line\n"); } else if ((done_status & NO_PAPER)) { printf("Printer is out of paper\n"); status = EAGAIN; } else { printf("Printer error, status is 0x%02X\n", done_status); } /* Some characters have been printed, tell how many. */ if (status == EAGAIN && user_left < orig_count) { status = orig_count - user_left; } oleft = 0; /* cancel further output */ } else if (user_left != 0) { /* not yet done, continue! */ prepare_output(); return; } else { /* done! report back to FS */ status = orig_count; } chardriver_reply_task(caller, write_id, status); writing = FALSE; /* unmark event */ }
static gboolean read_light (gpointer user_data) { DrvData *data = user_data; prepare_output (data, data->buffer_data->dev_dir_name, data->buffer_data->trigger_name); return G_SOURCE_CONTINUE; }
// ------------------------------------------------------------------ process -- void SpectacleBase::process(const float *buf, const int) { DPRINT("SpectacleBase::process"); if (_reading_input) { prepare_input(buf); _fft->r2c(); } modify_analysis(_reading_input); _fft->c2r(); prepare_output(); }
// ------------------------------------------------------------------ process -- void SPECTACLE2_BASE::process(const float *buf, const int) { DPRINT("SPECTACLE2_BASE::process\n"); const bool reading_input = (currentFrame() < _input_end_frame); if (reading_input) { DPRINT1("taking input...currentFrame()=%d\n", currentFrame()); prepare_input(buf); _fft->r2c(); cartesian_to_polar(); } modify_analysis(reading_input); polar_to_cartesian(); _fft->c2r(); prepare_output(); }
/*===========================================================================* * do_write * *===========================================================================*/ static ssize_t printer_write(devminor_t UNUSED(minor), u64_t UNUSED(position), endpoint_t endpt, cp_grant_id_t grant, size_t size, int flags, cdev_id_t id) { /* The printer is used by sending write requests to it. Process one. */ int retries; u32_t status; /* Reject command if last write is not yet finished, the count is not * positive, or we're asked not to block. */ if (writing) return EIO; if (size <= 0) return EINVAL; if (flags & CDEV_NONBLOCK) return EAGAIN; /* not supported */ /* If no errors occurred, continue printing with the caller. * First wait until the printer is online to prevent stupid errors. */ caller = endpt; user_left = size; orig_count = size; user_vir_d = 0; /* Offset. */ writing = TRUE; grant_nr = grant; write_id = id; retries = MAX_ONLINE_RETRIES + 1; while (--retries > 0) { if (sys_inb(port_base + 1, &status) != OK) { printf("printer: sys_inb of %x failed\n", port_base+1); panic("sys_inb failed"); } if (status & ON_LINE) { /* printer online! */ prepare_output(); printer_intr(0); return EDONTREPLY; /* we may already have sent a reply */ } micro_delay(500000); /* wait before retry */ } /* If we reach this point, the printer was not online in time. */ done_status = status; output_done(); return EDONTREPLY; }
int mxc_v4l_tvin_test(void) { struct v4l2_buffer capture_buf, output_buf; v4l2_std_id id; int i, j; enum v4l2_buf_type type; int total_time; struct timeval tv_start, tv_current; unsigned char *buf_test; buf_test = (unsigned char *) malloc (g_frame_size); if (prepare_output() < 0) { printf("prepare_output failed\n"); return TFAIL; } if (start_capturing() < 0) { printf("start_capturing failed\n"); return TFAIL; } for (i = 0; ; i++) { memset(&capture_buf, 0, sizeof(capture_buf)); capture_buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; capture_buf.memory = V4L2_MEMORY_MMAP; if (ioctl(fd_capture_v4l, VIDIOC_DQBUF, &capture_buf) < 0) { printf("VIDIOC_DQBUF failed.\n"); return TFAIL; } memset(&output_buf, 0, sizeof(output_buf)); output_buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; output_buf.memory = V4L2_MEMORY_MMAP; if (i < g_output_num_buffers) { output_buf.index = i; if (ioctl(fd_output_v4l, VIDIOC_QUERYBUF, &output_buf) < 0) { printf("VIDIOC_QUERYBUF failed\n"); return TFAIL; } } else { output_buf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT; output_buf.memory = V4L2_MEMORY_MMAP; if (ioctl(fd_output_v4l, VIDIOC_DQBUF, &output_buf) < 0) { printf("VIDIOC_DQBUF failed !!!\n"); return TFAIL; } } memcpy(buf_test, capture_buffers[capture_buf.index].start, g_frame_size); memcpy(output_buffers[output_buf.index].start, buf_test, g_frame_size); if (ioctl(fd_capture_v4l, VIDIOC_QBUF, &capture_buf) < 0) { printf("VIDIOC_QBUF failed\n"); return TFAIL; } output_buf.timestamp.tv_sec = tv_start.tv_sec; output_buf.timestamp.tv_usec = tv_start.tv_usec + (g_frame_period * i); if (ioctl(fd_output_v4l, VIDIOC_QBUF, &output_buf) < 0) { printf("VIDIOC_QBUF failed\n"); return TFAIL; } if (i == 1) { type = V4L2_BUF_TYPE_VIDEO_OUTPUT; if (ioctl(fd_output_v4l, VIDIOC_STREAMON, &type) < 0) { printf("Could not start stream\n"); return TFAIL; } } } gettimeofday(&tv_current, 0); total_time = (tv_current.tv_sec - tv_start.tv_sec) * 1000000L; total_time += tv_current.tv_usec - tv_start.tv_usec; printf("total time for %u frames = %u us = %lld fps\n", i, total_time, (i * 1000000ULL) / total_time); free (buf_test); return 0; }
int main(int argc, char **argv) { int c; int option_index = 0; struct config *config = NULL; config = prepare_default_config(); if (config == NULL) return EXIT_FAILURE; while (1) { c = getopt_long (argc, argv, "hg:o:s:l:vc:p:f:n:r:x:y:", long_options, &option_index); if (c == -1) break; switch (c) { case 'o': if (config->output != NULL) fclose(config->output); config->output = prepare_output(optarg); if (config->output == NULL) return EXIT_FAILURE; dprintf("user output path -> %s\n", optarg); break; case 's': sscanf(optarg, "%li", &config->sleep); dprintf("user sleep time -> %s\n", optarg); break; case 'l': sscanf(optarg, "%li", &config->load); dprintf("user load time -> %s\n", optarg); break; case 'c': sscanf(optarg, "%u", &config->cpu); dprintf("user cpu -> %s\n", optarg); break; case 'g': strncpy(config->governor, optarg, 14); dprintf("user governor -> %s\n", optarg); break; case 'p': if (string_to_prio(optarg) != SCHED_ERR) { config->prio = string_to_prio(optarg); dprintf("user prio -> %s\n", optarg); } else { if (config != NULL) { if (config->output != NULL) fclose(config->output); free(config); } usage(); } break; case 'n': sscanf(optarg, "%u", &config->cycles); dprintf("user cycles -> %s\n", optarg); break; case 'r': sscanf(optarg, "%u", &config->rounds); dprintf("user rounds -> %s\n", optarg); break; case 'x': sscanf(optarg, "%li", &config->load_step); dprintf("user load_step -> %s\n", optarg); break; case 'y': sscanf(optarg, "%li", &config->sleep_step); dprintf("user sleep_step -> %s\n", optarg); break; case 'f': if (prepare_config(optarg, config)) return EXIT_FAILURE; break; case 'v': config->verbose = 1; dprintf("verbose output enabled\n"); break; case 'h': case '?': default: if (config != NULL) { if (config->output != NULL) fclose(config->output); free(config); } usage(); } } if (config->verbose) { printf("starting benchmark with parameters:\n"); printf("config:\n\t" "sleep=%li\n\t" "load=%li\n\t" "sleep_step=%li\n\t" "load_step=%li\n\t" "cpu=%u\n\t" "cycles=%u\n\t" "rounds=%u\n\t" "governor=%s\n\n", config->sleep, config->load, config->sleep_step, config->load_step, config->cpu, config->cycles, config->rounds, config->governor); } prepare_user(config); prepare_system(config); start_benchmark(config); if (config->output != stdout) fclose(config->output); free(config); return EXIT_SUCCESS; }
void streamClose(struct stream *s) { prepare_output(s); output(s); json_object_put(s->json); }