34
45
volatile int run_started;
47
struct timeval tv_started;
48
struct timeval tv_last_written;
51
unsigned long frames, lost;
52
unsigned long last_frames, last_lost;
37
63
typedef struct setup_s setup_t;
39
void handle_error(GError *error) {
66
#ifdef USE_UFO_GENERATOR
67
static void handle_error(GError *error) {
40
68
if (error != NULL) {
41
69
g_print("%s\n", error->message);
42
70
g_error_free(error);
43
71
exit(EXIT_FAILURE);
47
void set_speed(setup_t *setup, size_t speed) {
74
#endif /* USE_UFO_GENERATOR */
77
static void set_dim(setup_t *setup, size_t width, size_t height) {
48
78
setup->bpp = sizeof(float);
80
setup->height = height;
82
setup->frame_size = setup->width * setup->height * setup->bpp;
85
static void set_speed(setup_t *setup, size_t speed) {
51
86
setup->fps = 1 + speed / setup->width / setup->height / setup->bpp;
54
void set_size(setup_t *setup, size_t size) {
89
static void set_size(setup_t *setup, size_t size) {
55
90
setup->iters = size / setup->width / setup->height / setup->bpp;
58
void set_time(setup_t *setup, size_t time) {
93
static void set_time(setup_t *setup, size_t time) {
59
94
setup->iters = time * setup->fps;
97
static int callback(setup_t *s, size_t result, void *buffer);
62
99
static void *run(setup_t *setup) {
100
#ifdef USE_UFO_GENERATOR
63
101
GError *error = NULL;
64
102
UfoGraph *graph = NULL;
65
103
/* If you want to use system-wide installed filters:
66
104
* graph = ufo_graph_new(); */
68
106
graph = g_object_new(UFO_TYPE_GRAPH,
107
# ifdef METABALLS_PATH
70
108
"paths", METABALLS_PATH,
71
#endif /* METABALLS_PATH */
109
# endif /* METABALLS_PATH */
74
112
// printf("%lu %lu %lu %lu\n", setup->width, setup->height, setup->iters, setup->width * setup->height * setup->iters * sizeof(float));
92
130
handle_error(error);
94
132
setup->run_started = 1;
95
134
ufo_graph_run(graph, &error);
96
135
handle_error(error);
99
// g_print("Wrote %lu bytes\n", width * height * num_iterations * sizeof(float));
136
#else /* USE_UFO_GENERATOR */
139
size_t size = setup->width * setup->height * setup->bpp;
141
double interval = 1000000. / setup->fps, nextus;
145
setup->run_started = 1;
148
int fd = open(fifo_name, O_WRONLY);
150
#endif /* USE_FIFO */
152
gettimeofday(&tv, NULL);
154
nextus = tv.tv_usec + interval;
155
for (i = 0; i < setup->iters; i++) {
157
ssize_t res = write(fd, buffer, size);
158
g_assert(res == size);
160
callback(setup, size, buffer);
161
#endif /* USE_FIFO */
163
tmp = ((size_t)round(nextus)) / 1000000;
165
nextus -= tmp * 1000000;
167
gettimeofday(&tv, NULL);
168
tmp = (nexts - tv.tv_sec)*1000000 + (nextus - tv.tv_usec);
169
if (tmp > 10) usleep(tmp);
176
#endif /* USE_FIFO */
178
#endif /* USE_UFO_GENERATOR */
101
180
g_thread_exit(NULL);
184
static int callback(setup_t *s, size_t result, void *buffer) {
188
fastwriter_t *fw = s->fw;
189
fastwriter_stats_t stats;
191
size_t duration, last_duration, expected;
195
if (!s->broken_frame) {
196
err = fastwriter_push(fw, result, buffer);
198
if (err == EWOULDBLOCK) {
199
if (s->num_read) fastwriter_cancel(fw);
202
if (err) printf("FastWriter returned error %i\n", err);
208
s->num_read += result;
210
if (s->num_read < s->frame_size) return 0;
214
if (s->broken_frame) {
218
err = fastwriter_commit(fw);
222
gettimeofday(&tv, NULL);
223
if (!s->tv_started.tv_sec) {
224
memcpy(&s->tv_started, &tv, sizeof(struct timeval));
225
if (s->tv_started.tv_usec >= (1000000 / s->fps))
226
s->tv_started.tv_usec -= (1000000 / s->fps);
228
s->tv_started.tv_sec--;
229
s->tv_started.tv_usec += 1000000 - (1000000 / s->fps);
231
memcpy(&s->tv_last_written, &s->tv_started, sizeof(struct timeval));
234
fastwriter_get_stats(fw, &stats);
235
if (stats.buffer_used > s->buf_max) s->buf_max = stats.buffer_used;
237
if ((tv.tv_sec - s->tv_last_written.tv_sec) >= WRITE_INTERVAL) {
238
last_duration = (tv.tv_sec - s->tv_last_written.tv_sec) * 1000000 + (tv.tv_usec - s->tv_last_written.tv_usec);
240
printf("Lost %6.2lf%% (% 8lu of % 8lu), %9.3lf GB at %8.3lf MB/s, buf:%6.2lf%%\n", 100.*(s->lost - s->last_lost) / (s->lost + s->frames - s->last_lost - s->last_frames), s->lost - s->last_lost, s->lost + s->frames - (s->last_lost + s->last_frames), 1. * s->frame_size * (s->frames - s->last_frames) / 1024 / 1024 / 1024, 1000000. * s->frame_size * (s->frames - s->last_frames) / last_duration / 1024 / 1024, 100.*s->buf_max/stats.buffer_size);
242
if (((++s->writeouts)%WRITE_SUMMARY)==0) {
243
duration = (tv.tv_sec - s->tv_started.tv_sec) * 1000000 + (tv.tv_usec - s->tv_started.tv_usec);
244
expected = (tv.tv_sec - s->tv_started.tv_sec) * s->fps + round(1.*(tv.tv_usec - s->tv_started.tv_usec)*s->fps/1000000);
245
delta = expected - s->lost - s->frames;
246
if ((delta > DELTA_TOLERANCE)||(delta < -DELTA_TOLERANCE))
247
printf(" *** Unexpected frame rate: %.2lf (%lu), delta: %li (%lu, %lu)\n", 1000000. * (s->frames + s->lost) / duration, s->fps, delta, s->lost + s->frames, expected);
249
printf("Total %6.2lf%% (% 8lu of % 8lu), %9.3lf GB at %8.3lf MB/s, buf:%6.2lf%%\n", 100. * s->lost / (s->lost + s->frames), s->lost, s->lost + s->frames, 1. * s->frames * s->frame_size / 1024 / 1024 / 1024, 1000000. * s->frames * s->frame_size / duration / 1024 / 1024, 100.*stats.buffer_max / stats.buffer_size);
253
memcpy(&s->tv_last_written, &tv, sizeof(struct timeval));
254
s->last_frames = s->frames;
255
s->last_lost = s->lost;
108
262
int main(int argc, char const* argv[])
269
#endif /* USE_FIFO */
115
fastwriter_stats_t stats;
116
272
const char *out = "/dev/null";
117
275
size_t speed = 850;
122
int broken_frame = 0;
123
size_t writeouts = 0;
124
size_t duration, last_duration;
126
struct timeval tv_started = {0};
127
struct timeval tv_last_written = {0};
128
unsigned long frames = 0, lost = 0;
129
unsigned long delta, expected;
130
unsigned long last_frames = 0, last_lost = 0;
278
fastwriter_stats_t stats;
282
#ifdef USE_UFO_GENERATOR
284
#endif /* USE_UFO_GENERATOR */
141
291
speed = atoi(argv[2]);
144
295
unlink(fifo_name);
145
296
g_assert(!mkfifo(fifo_name, S_IWUSR | S_IRUSR));
297
#endif /* USE_FIFO */
147
299
fw = fastwriter_init(out, FASTWRITER_FLAGS_OVERWRITE);
150
302
err = fastwriter_open(fw, out, FASTWRITER_FLAGS_OVERWRITE);
151
303
if (err) printf("FastWriter returned error %i\n", err);
155
306
fastwriter_set_buffer_size(fw, FW_BUFFER * 1024 * 1024);
157
308
fastwriter_get_stats(fw, &stats);
158
printf("*** Writing to %s, speed: %lu MB/s, buffer: %lu MB\n", out, speed, stats.buffer_size);
160
310
memset(&setup, 0, sizeof(setup_t));
313
set_dim(&setup, width, height);
161
314
set_speed(&setup, speed * 1024 * 1024);
162
315
set_size(&setup, run_time * speed * 1024 * 1024);
164
size_t frame_size = setup.width * setup.height * setup.bpp;
165
void *buffer = malloc(frame_size);
317
printf("*** Writing to %s, rate: %lu, data: %lu MB/s, buffer: %lu MB\n", out, setup.fps, speed, stats.buffer_size);
319
void *buffer = malloc(setup.frame_size);
166
320
g_assert(buffer);
168
323
thr = g_thread_create((GThreadFunc)run, &setup, 1, &gerr);
173
328
int fd = open(fifo_name, O_RDONLY);
176
ssize_t result = read(fd, buffer, frame_size);
331
ssize_t result = read(fd, buffer, setup.frame_size);
178
333
while (result > 0) {
180
err = fastwriter_push(fw, result, buffer);
182
if (err == EWOULDBLOCK) {
183
if (num_read) fastwriter_cancel(fw);
186
if (err) printf("FastWriter returned error %i\n", err);
194
if (num_read < frame_size) {
195
result = read(fd, buffer, frame_size - num_read);
199
gettimeofday(&tv, NULL);
200
if (!tv_started.tv_sec) {
201
memcpy(&tv_started, &tv, sizeof(struct timeval));
202
if (tv_started.tv_usec >= (1000000 / setup.fps))
203
tv_started.tv_usec -= (1000000 / setup.fps);
206
tv_started.tv_usec += 1000000 - (1000000 / setup.fps);
208
memcpy(&tv_last_written, &tv_started, sizeof(struct timeval));
216
err = fastwriter_commit(fw);
220
fastwriter_get_stats(fw, &stats);
221
if (stats.buffer_used > buf_max) buf_max = stats.buffer_used;
223
if ((tv.tv_sec - tv_last_written.tv_sec) >= WRITE_INTERVAL) {
224
last_duration = (tv.tv_sec - tv_last_written.tv_sec) * 1000000 + (tv.tv_usec - tv_last_written.tv_usec);
226
/* expected = (tv.tv_sec - tv_last_summary.tv_sec) * setup.fps + (tv.tv_usec - tv_last_summary.tv_usec) * setup.fps / 1000000;
227
delta = expected - lost - frames;
228
if (delta > 0) delta--;*/
230
printf("Lost %6.2lf%% (% 8lu of % 8lu), %9.3lf GB at %8.3lf MB/s, buf:%6.2lf%%\n", 100.*(lost - last_lost) / (lost + frames - last_lost - last_frames), lost - last_lost, lost + frames - (last_lost + last_frames), 1. * frame_size * (frames - last_frames) / 1024 / 1024 / 1024, 1000000. * frame_size * (frames - last_frames) / last_duration / 1024 / 1024, 100.*buf_max/stats.buffer_size);
232
if (((++writeouts)%WRITE_SUMMARY)==0) {
233
duration = (tv.tv_sec - tv_started.tv_sec) * 1000000 + (tv.tv_usec - tv_started.tv_usec);
235
expected = (tv.tv_sec - tv_started.tv_sec) * setup.fps + round(1.*(tv.tv_usec - tv_started.tv_usec)*setup.fps/1000000);
237
delta = expected - lost - frames;
238
if ((delta > 1)||(delta < 1))
239
printf(" *** Unexpected frame rate: %.2lf (%lu), delta: %li (%lu, %lu)\n", 1000000. * (frames + lost) / duration, setup.fps, delta, lost + frames, expected);
241
printf("Total %6.2lf%% (% 8lu of % 8lu), %9.3lf GB at %8.3lf MB/s, buf:%6.2lf%%\n", 100.*lost / (lost + frames), lost, lost + frames, 1. * frames * frame_size / 1024 / 1024 / 1024, 1000000. * frames * frame_size / duration / 1024 / 1024, 100.*stats.buffer_max / stats.buffer_size);
245
memcpy(&tv_last_written, &tv, sizeof(struct timeval));
246
last_frames = frames;
250
result = read(fd, buffer, frame_size);
334
callback(&setup, result, buffer);
335
result = read(fd, buffer, setup.frame_size - setup.num_read);
253
printf("Wrote %lu GB\n", frame_size * frames / 1024 / 1024 / 1024);
338
printf("Wrote %lu GB\n", setup.frame_size * setup.frames / 1024 / 1024 / 1024);
255
340
g_thread_join(thr);
345
#endif /* USE_FIFO */
260
348
fastwriter_close(fw);
261
349
fastwriter_destroy(fw);
262
352
unlink(fifo_name);
353
#endif /* USE_FIFO */