rarias/ovni
rarias/ovni
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Remove emu prefix from trace and stream

Browse Source
This commit is contained in:
Rodrigo Arias 2023-02-01 12:33:19 +01:00 committed by Rodrigo Arias Mallo
parent 242ea71ee6
commit 8ed9063488
15 changed files with 112 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/emu/CMakeLists.txt
View File

@ -19,8 +19,8 @@ add_library(emu STATIC
emu_ev.c emu_ev.c
emu_model.c emu_model.c
emu_player.c emu_player.c
emu_stream.c stream.c
emu_trace.c trace.c
loom.c loom.c
metadata.c metadata.c
mux.c mux.c

2
src/emu/emu.c
View File

@ -18,7 +18,7 @@ emu_init(struct emu *emu, int argc, char *argv[])
emu_args_init(&emu->args, argc, argv); emu_args_init(&emu->args, argc, argv);
/* Load the streams into the trace */ /* Load the streams into the trace */
if (emu_trace_load(&emu->trace, emu->args.tracedir) != 0) { if (trace_load(&emu->trace, emu->args.tracedir) != 0) {
err("cannot load trace '%s'\n", emu->args.tracedir); err("cannot load trace '%s'\n", emu->args.tracedir);
return -1; return -1;
} }

6
src/emu/emu.h
View File

@ -5,7 +5,7 @@
#define EMU_H #define EMU_H
#include "bay.h" #include "bay.h"
#include "emu_trace.h" #include "trace.h"
#include "emu_args.h" #include "emu_args.h"
#include "system.h" #include "system.h"
#include "emu_player.h" #include "emu_player.h"
@ -22,14 +22,14 @@ struct emu {
struct bay bay; struct bay bay;
struct emu_args args; struct emu_args args;
struct emu_trace trace; struct trace trace;
struct system system; struct system system;
struct emu_player player; struct emu_player player;
struct emu_model model; struct emu_model model;
struct recorder recorder; struct recorder recorder;
/* Quick access */ /* Quick access */
struct emu_stream *stream; struct stream *stream;
struct emu_ev *ev; struct emu_ev *ev;
struct thread *thread; struct thread *thread;
struct proc *proc; struct proc *proc;

30
src/emu/emu_player.c
View File

@ -15,13 +15,13 @@
static inline int static inline int
stream_cmp(heap_node_t *a, heap_node_t *b) stream_cmp(heap_node_t *a, heap_node_t *b)
{ {
struct emu_stream *sa, *sb; struct stream *sa, *sb;
sa = heap_elem(a, struct emu_stream, hh); sa = heap_elem(a, struct stream, hh);
sb = heap_elem(b, struct emu_stream, hh); sb = heap_elem(b, struct stream, hh);
int64_t ca = emu_stream_lastclock(sa); int64_t ca = stream_lastclock(sa);
int64_t cb = emu_stream_lastclock(sb); int64_t cb = stream_lastclock(sb);
/* Return the opposite, so we have min-heap */ /* Return the opposite, so we have min-heap */
if (ca < cb) if (ca < cb)
@ -33,12 +33,12 @@ stream_cmp(heap_node_t *a, heap_node_t *b)
} }
static int static int
step_stream(struct emu_player *player, struct emu_stream *stream) step_stream(struct emu_player *player, struct stream *stream)
{ {
if (!stream->active) if (!stream->active)
return +1; return +1;
int ret = emu_stream_step(stream); int ret = stream_step(stream);
if (ret < 0) { if (ret < 0) {
err("step_stream: cannot step stream '%s'\n", err("step_stream: cannot step stream '%s'\n",
@ -54,7 +54,7 @@ step_stream(struct emu_player *player, struct emu_stream *stream)
} }
int int
emu_player_init(struct emu_player *player, struct emu_trace *trace) emu_player_init(struct emu_player *player, struct trace *trace)
{ {
memset(player, 0, sizeof(struct emu_player)); memset(player, 0, sizeof(struct emu_player));
@ -64,7 +64,7 @@ emu_player_init(struct emu_player *player, struct emu_trace *trace)
player->stream = NULL; player->stream = NULL;
/* Load initial streams and events */ /* Load initial streams and events */
struct emu_stream *stream; struct stream *stream;
DL_FOREACH(trace->streams, stream) { DL_FOREACH(trace->streams, stream) {
int ret = step_stream(player, stream); int ret = step_stream(player, stream);
if (ret > 0) { if (ret > 0) {
@ -80,7 +80,7 @@ emu_player_init(struct emu_player *player, struct emu_trace *trace)
} }
static int static int
update_clocks(struct emu_player *player, struct emu_stream *stream) update_clocks(struct emu_player *player, struct stream *stream)
{ {
/* This can happen if two events are not ordered in the stream, but the /* This can happen if two events are not ordered in the stream, but the
* emulator picks other events in the middle. Example: * emulator picks other events in the middle. Example:
@ -95,7 +95,7 @@ update_clocks(struct emu_player *player, struct emu_stream *stream)
* 12 * 12
* ... * ...
* */ * */
int64_t sclock = emu_stream_lastclock(stream); int64_t sclock = stream_lastclock(stream);
if (player->first_event) { if (player->first_event) {
player->first_event = 0; player->first_event = 0;
@ -133,7 +133,7 @@ emu_player_step(struct emu_player *player)
if (node == NULL) if (node == NULL)
return +1; return +1;
struct emu_stream *stream = heap_elem(node, struct emu_stream, hh); struct stream *stream = heap_elem(node, struct stream, hh);
if (stream == NULL) { if (stream == NULL) {
err("emu_player_step: heap_elem() returned NULL\n"); err("emu_player_step: heap_elem() returned NULL\n");
@ -147,8 +147,8 @@ emu_player_step(struct emu_player *player)
player->stream = stream; player->stream = stream;
struct ovni_ev *oev = emu_stream_ev(stream); struct ovni_ev *oev = stream_ev(stream);
int64_t sclock = emu_stream_evclock(stream, oev); int64_t sclock = stream_evclock(stream, oev);
emu_ev(&player->ev, oev, sclock, player->deltaclock); emu_ev(&player->ev, oev, sclock, player->deltaclock);
return 0; return 0;
@ -160,7 +160,7 @@ emu_player_ev(struct emu_player *player)
return &player->ev; return &player->ev;
} }
struct emu_stream * struct stream *
emu_player_stream(struct emu_player *player) emu_player_stream(struct emu_player *player)
{ {
return player->stream; return player->stream;

8
src/emu/emu_player.h
View File

@ -4,7 +4,7 @@
#ifndef EMU_PLAYER_H #ifndef EMU_PLAYER_H
#define EMU_PLAYER_H #define EMU_PLAYER_H
#include "emu_trace.h" #include "trace.h"
#include "emu_ev.h" #include "emu_ev.h"
#include <linux/limits.h> #include <linux/limits.h>
@ -15,13 +15,13 @@ struct emu_player {
int64_t lastclock; int64_t lastclock;
int64_t deltaclock; int64_t deltaclock;
int first_event; int first_event;
struct emu_stream *stream; struct stream *stream;
struct emu_ev ev; struct emu_ev ev;
}; };
int emu_player_init(struct emu_player *player, struct emu_trace *trace); int emu_player_init(struct emu_player *player, struct trace *trace);
int emu_player_step(struct emu_player *player); int emu_player_step(struct emu_player *player);
struct emu_ev *emu_player_ev(struct emu_player *player); struct emu_ev *emu_player_ev(struct emu_player *player);
struct emu_stream *emu_player_stream(struct emu_player *player); struct stream *emu_player_stream(struct emu_player *player);
#endif /* EMU_PLAYER_H */ #endif /* EMU_PLAYER_H */

50
src/emu/emu_stream.c → src/emu/stream.c
View File

@ -1,7 +1,7 @@
/* Copyright (c) 2021-2023 Barcelona Supercomputing Center (BSC) /* Copyright (c) 2021-2023 Barcelona Supercomputing Center (BSC)
* SPDX-License-Identifier: GPL-3.0-or-later */ * SPDX-License-Identifier: GPL-3.0-or-later */
#include "emu_stream.h" #include "stream.h"
#include "ovni.h" #include "ovni.h"
#include <sys/stat.h> #include <sys/stat.h>
@ -10,7 +10,7 @@
#include <unistd.h> #include <unistd.h>
static int static int
check_stream_header(struct emu_stream *stream) check_stream_header(struct stream *stream)
{ {
int ret = 0; int ret = 0;
@ -42,7 +42,7 @@ check_stream_header(struct emu_stream *stream)
} }
static int static int
load_stream_fd(struct emu_stream *stream, int fd) load_stream_fd(struct stream *stream, int fd)
{ {
struct stat st; struct stat st;
if (fstat(fd, &st) < 0) { if (fstat(fd, &st) < 0) {
@ -70,35 +70,35 @@ load_stream_fd(struct emu_stream *stream, int fd)
} }
int int
emu_stream_load(struct emu_stream *stream, const char *tracedir, const char *relpath) stream_load(struct stream *stream, const char *tracedir, const char *relpath)
{ {
int fd; int fd;
if (snprintf(stream->path, PATH_MAX, "%s/%s", tracedir, relpath) >= PATH_MAX) { if (snprintf(stream->path, PATH_MAX, "%s/%s", tracedir, relpath) >= PATH_MAX) {
err("emu_stream_load: path too long: %s/%s\n", tracedir, relpath); err("stream_load: path too long: %s/%s\n", tracedir, relpath);
return -1; return -1;
} }
if (snprintf(stream->relpath, PATH_MAX, "%s", relpath) >= PATH_MAX) { if (snprintf(stream->relpath, PATH_MAX, "%s", relpath) >= PATH_MAX) {
err("emu_stream_load: path too long: %s\n", relpath); err("stream_load: path too long: %s\n", relpath);
return -1; return -1;
} }
dbg("emu_stream_load: loading %s\n", stream->relpath); dbg("stream_load: loading %s\n", stream->relpath);
if ((fd = open(stream->path, O_RDWR)) == -1) { if ((fd = open(stream->path, O_RDWR)) == -1) {
err("emu_stream_load: open failed: %s\n", stream->path); err("stream_load: open failed: %s\n", stream->path);
return -1; return -1;
} }
if (load_stream_fd(stream, fd) != 0) { if (load_stream_fd(stream, fd) != 0) {
err("emu_stream_load: load_stream_fd failed for stream '%s'\n", err("stream_load: load_stream_fd failed for stream '%s'\n",
stream->path); stream->path);
return -1; return -1;
} }
if (check_stream_header(stream) != 0) { if (check_stream_header(stream) != 0) {
err("emu_stream_load: stream '%s' has bad header\n", err("stream_load: stream '%s' has bad header\n",
stream->path); stream->path);
return -1; return -1;
} }
@ -112,7 +112,7 @@ emu_stream_load(struct emu_stream *stream, const char *tracedir, const char *rel
err("warning: stream '%s' has zero events\n", stream->relpath); err("warning: stream '%s' has zero events\n", stream->relpath);
stream->active = 0; stream->active = 0;
} else { } else {
err("emu_stream_load: impossible, offset %ld bigger than size %ld\n", err("stream_load: impossible, offset %ld bigger than size %ld\n",
stream->offset, stream->size); stream->offset, stream->size);
return -1; return -1;
} }
@ -127,28 +127,28 @@ emu_stream_load(struct emu_stream *stream, const char *tracedir, const char *rel
} }
void void
emu_stream_data_set(struct emu_stream *stream, void *data) stream_data_set(struct stream *stream, void *data)
{ {
stream->data = data; stream->data = data;
} }
void * void *
emu_stream_data_get(struct emu_stream *stream) stream_data_get(struct stream *stream)
{ {
return stream->data; return stream->data;
} }
int int
emu_stream_clkoff_set(struct emu_stream *stream, int64_t clkoff) stream_clkoff_set(struct stream *stream, int64_t clkoff)
{ {
if (stream->cur_ev) { if (stream->cur_ev) {
die("emu_stream_clkoff_set: cannot set clokoff in started stream '%s'\n", die("stream_clkoff_set: cannot set clokoff in started stream '%s'\n",
stream->relpath); stream->relpath);
return -1; return -1;
} }
if (stream->clock_offset != 0) { if (stream->clock_offset != 0) {
err("emu_stream_clkoff_set: stream '%s' already has a clock offset\n", err("stream_clkoff_set: stream '%s' already has a clock offset\n",
stream->relpath); stream->relpath);
return -1; return -1;
} }
@ -159,28 +159,28 @@ emu_stream_clkoff_set(struct emu_stream *stream, int64_t clkoff)
} }
struct ovni_ev * struct ovni_ev *
emu_stream_ev(struct emu_stream *stream) stream_ev(struct stream *stream)
{ {
return stream->cur_ev; return stream->cur_ev;
} }
int64_t int64_t
emu_stream_evclock(struct emu_stream *stream, struct ovni_ev *ev) stream_evclock(struct stream *stream, struct ovni_ev *ev)
{ {
return (int64_t) ovni_ev_get_clock(ev) + stream->clock_offset; return (int64_t) ovni_ev_get_clock(ev) + stream->clock_offset;
} }
int64_t int64_t
emu_stream_lastclock(struct emu_stream *stream) stream_lastclock(struct stream *stream)
{ {
return stream->lastclock; return stream->lastclock;
} }
int int
emu_stream_step(struct emu_stream *stream) stream_step(struct stream *stream)
{ {
if (!stream->active) { if (!stream->active) {
err("emu_stream_step: stream is inactive, cannot step\n"); err("stream_step: stream is inactive, cannot step\n");
return -1; return -1;
} }
@ -190,7 +190,7 @@ emu_stream_step(struct emu_stream *stream)
/* It cannot pass the size, otherwise we are reading garbage */ /* It cannot pass the size, otherwise we are reading garbage */
if (stream->offset > stream->size) { if (stream->offset > stream->size) {
err("emu_stream_step: stream offset %ld exceeds size %ld\n", err("stream_step: stream offset %ld exceeds size %ld\n",
stream->offset, stream->size); stream->offset, stream->size);
return -1; return -1;
} }
@ -207,13 +207,13 @@ emu_stream_step(struct emu_stream *stream)
/* Ensure the event fits */ /* Ensure the event fits */
if (stream->offset + ovni_ev_size(stream->cur_ev) > stream->size) { if (stream->offset + ovni_ev_size(stream->cur_ev) > stream->size) {
err("emu_stream_step: stream '%s' ends with incomplete event\n", err("stream_step: stream '%s' ends with incomplete event\n",
stream->relpath); stream->relpath);
return -1; return -1;
} }
/* Ensure the clock grows monotonically */ /* Ensure the clock grows monotonically */
int64_t clock = emu_stream_evclock(stream, stream->cur_ev); int64_t clock = stream_evclock(stream, stream->cur_ev);
if (clock < stream->lastclock) { if (clock < stream->lastclock) {
err("clock goes backwards %ld -> %ld in stream '%s' at offset %ld\n", err("clock goes backwards %ld -> %ld in stream '%s' at offset %ld\n",
stream->lastclock, stream->lastclock,
@ -228,7 +228,7 @@ emu_stream_step(struct emu_stream *stream)
} }
double double
emu_stream_progress(struct emu_stream *stream) stream_progress(struct stream *stream)
{ {
if (stream->usize == 0) if (stream->usize == 0)
return 1.0; return 1.0;

26
src/emu/emu_stream.h → src/emu/stream.h
View File

@ -9,9 +9,9 @@
#include <stdint.h> #include <stdint.h>
#include <linux/limits.h> #include <linux/limits.h>
struct emu_stream; struct stream;
struct emu_stream { struct stream {
char path[PATH_MAX]; char path[PATH_MAX];
char relpath[PATH_MAX]; /* To tracedir */ char relpath[PATH_MAX]; /* To tracedir */
@ -28,26 +28,26 @@ struct emu_stream {
int64_t clock_offset; int64_t clock_offset;
heap_node_t hh; heap_node_t hh;
struct emu_stream *next; struct stream *next;
struct emu_stream *prev; struct stream *prev;
struct ovni_ev *cur_ev; struct ovni_ev *cur_ev;
void *data; /* To hold system details */ void *data; /* To hold system details */
}; };
int emu_stream_load(struct emu_stream *stream, int stream_load(struct stream *stream,
const char *tracedir, const char *relpath); const char *tracedir, const char *relpath);
int emu_stream_clkoff_set(struct emu_stream *stream, int64_t clock_offset); int stream_clkoff_set(struct stream *stream, int64_t clock_offset);
double emu_stream_progress(struct emu_stream *stream); double stream_progress(struct stream *stream);
int emu_stream_step(struct emu_stream *stream); int stream_step(struct stream *stream);
struct ovni_ev *emu_stream_ev(struct emu_stream *stream); struct ovni_ev *stream_ev(struct stream *stream);
int64_t emu_stream_evclock(struct emu_stream *stream, struct ovni_ev *ev); int64_t stream_evclock(struct stream *stream, struct ovni_ev *ev);
int64_t emu_stream_lastclock(struct emu_stream *stream); int64_t stream_lastclock(struct stream *stream);
void emu_stream_data_set(struct emu_stream *stream, void *data); void stream_data_set(struct stream *stream, void *data);
void *emu_stream_data_get(struct emu_stream *stream); void *stream_data_get(struct stream *stream);
#endif /* EMU_STREAM_H */ #endif /* EMU_STREAM_H */

18
src/emu/system.c
View File

@ -137,7 +137,7 @@ create_loom(struct system *sys, const char *relpath)
} }
static int static int
create_system(struct system *sys, struct emu_trace *trace) create_system(struct system *sys, struct trace *trace)
{ {
const char *dir = trace->tracedir; const char *dir = trace->tracedir;
@ -149,7 +149,7 @@ create_system(struct system *sys, struct emu_trace *trace)
} }
size_t i = 0; size_t i = 0;
for (struct emu_stream *s = trace->streams; s ; s = s->next) { for (struct stream *s = trace->streams; s ; s = s->next) {
if (!loom_matches(s->relpath)) { if (!loom_matches(s->relpath)) {
err("warning: ignoring unknown stream %s", s->relpath); err("warning: ignoring unknown stream %s", s->relpath);
continue; continue;
@ -180,7 +180,7 @@ create_system(struct system *sys, struct emu_trace *trace)
lpt->proc = proc; lpt->proc = proc;
lpt->thread = thread; lpt->thread = thread;
emu_stream_data_set(s, lpt); stream_data_set(s, lpt);
} }
return 0; return 0;
@ -396,7 +396,7 @@ parse_clkoff_entry(struct loom *looms, struct clkoff_entry *entry)
} }
static int static int
init_offsets(struct system *sys, struct emu_trace *trace) init_offsets(struct system *sys, struct trace *trace)
{ {
struct clkoff *table = &sys->clkoff; struct clkoff *table = &sys->clkoff;
int n = clkoff_count(table); int n = clkoff_count(table);
@ -419,7 +419,7 @@ init_offsets(struct system *sys, struct emu_trace *trace)
} }
} }
for (struct emu_stream *s = trace->streams; s; s = s->next) { for (struct stream *s = trace->streams; s; s = s->next) {
struct lpt *lpt = system_get_lpt(s); struct lpt *lpt = system_get_lpt(s);
if (lpt == NULL) { if (lpt == NULL) {
err("cannot get stream lpt"); err("cannot get stream lpt");
@ -427,7 +427,7 @@ init_offsets(struct system *sys, struct emu_trace *trace)
} }
int64_t offset = lpt->loom->clock_offset; int64_t offset = lpt->loom->clock_offset;
if (emu_stream_clkoff_set(s, offset) != 0) { if (stream_clkoff_set(s, offset) != 0) {
err("cannot set clock offset"); err("cannot set clock offset");
return -1; return -1;
} }
@ -471,7 +471,7 @@ init_end_system(struct system *sys)
} }
int int
system_init(struct system *sys, struct emu_args *args, struct emu_trace *trace) system_init(struct system *sys, struct emu_args *args, struct trace *trace)
{ {
memset(sys, 0, sizeof(struct system)); memset(sys, 0, sizeof(struct system));
sys->args = args; sys->args = args;
@ -522,9 +522,9 @@ system_init(struct system *sys, struct emu_args *args, struct emu_trace *trace)
} }
struct lpt * struct lpt *
system_get_lpt(struct emu_stream *stream) system_get_lpt(struct stream *stream)
{ {
struct lpt *lpt = emu_stream_data_get(stream); struct lpt *lpt = stream_data_get(stream);
if (lpt->stream != stream) if (lpt->stream != stream)
die("inconsistent stream in lpt map"); die("inconsistent stream in lpt map");

10
src/emu/system.h
View File

@ -5,8 +5,8 @@
#define EMU_SYSTEM_H #define EMU_SYSTEM_H
#include "emu_args.h" #include "emu_args.h"
#include "emu_trace.h" #include "trace.h"
#include "emu_stream.h" #include "stream.h"
#include "loom.h" #include "loom.h"
#include "proc.h" #include "proc.h"
#include "thread.h" #include "thread.h"
@ -17,7 +17,7 @@
/* Map from stream to lpt */ /* Map from stream to lpt */
struct lpt { struct lpt {
struct emu_stream *stream; /* Redundancy */ struct stream *stream; /* Redundancy */
struct loom *loom; struct loom *loom;
struct proc *proc; struct proc *proc;
struct thread *thread; struct thread *thread;
@ -43,9 +43,9 @@ struct system {
//struct model_ctx ctx; //struct model_ctx ctx;
}; };
int system_init(struct system *sys, struct emu_args *args, struct emu_trace *trace); int system_init(struct system *sys, struct emu_args *args, struct trace *trace);
int system_connect(struct system *sys, struct bay *bay, struct recorder *rec); int system_connect(struct system *sys, struct bay *bay, struct recorder *rec);
struct lpt *system_get_lpt(struct emu_stream *stream); struct lpt *system_get_lpt(struct stream *stream);
//struct emu_cpu *system_find_cpu(struct emu_loom *loom, int cpuid); //struct emu_cpu *system_find_cpu(struct emu_loom *loom, int cpuid);
//int model_ctx_set(struct model_ctx *ctx, int model, void *data); //int model_ctx_set(struct model_ctx *ctx, int model, void *data);
//int model_ctx_get(struct model_ctx *ctx, int model, void *data); //int model_ctx_get(struct model_ctx *ctx, int model, void *data);

18
src/emu/emu_trace.c → src/emu/trace.c
View File

@ -3,7 +3,7 @@
#define _XOPEN_SOURCE 500 #define _XOPEN_SOURCE 500
#include "emu_trace.h" #include "trace.h"
#include "utlist.h" #include "utlist.h"
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -11,19 +11,19 @@
/* See the nftw(3) manual to see why we need a global variable here: /* See the nftw(3) manual to see why we need a global variable here:
* https://pubs.opengroup.org/onlinepubs/9699919799/functions/nftw.html */ * https://pubs.opengroup.org/onlinepubs/9699919799/functions/nftw.html */
static struct emu_trace *cur_trace = NULL; static struct trace *cur_trace = NULL;
static void static void
add_stream(struct emu_trace *trace, struct emu_stream *stream) add_stream(struct trace *trace, struct stream *stream)
{ {
DL_APPEND(trace->streams, stream); DL_APPEND(trace->streams, stream);
trace->nstreams++; trace->nstreams++;
} }
static int static int
load_stream(struct emu_trace *trace, const char *path) load_stream(struct trace *trace, const char *path)
{ {
struct emu_stream *stream = calloc(1, sizeof(struct emu_stream)); struct stream *stream = calloc(1, sizeof(struct stream));
if (stream == NULL) { if (stream == NULL) {
perror("calloc failed"); perror("calloc failed");
@ -36,7 +36,7 @@ load_stream(struct emu_trace *trace, const char *path)
/* Skip begin slashes */ /* Skip begin slashes */
while (relpath[0] == '/') relpath++; while (relpath[0] == '/') relpath++;
if (emu_stream_load(stream, trace->tracedir, relpath) != 0) { if (stream_load(stream, trace->tracedir, relpath) != 0) {
err("load_stream: emu_steam_load failed\n"); err("load_stream: emu_steam_load failed\n");
return -1; return -1;
} }
@ -82,15 +82,15 @@ cb_nftw(const char *fpath, const struct stat *sb,
} }
static int static int
cmp_streams(struct emu_stream *a, struct emu_stream *b) cmp_streams(struct stream *a, struct stream *b)
{ {
return strcmp(a->relpath, b->relpath); return strcmp(a->relpath, b->relpath);
} }
int int
emu_trace_load(struct emu_trace *trace, const char *tracedir) trace_load(struct trace *trace, const char *tracedir)
{ {
memset(trace, 0, sizeof(struct emu_trace)); memset(trace, 0, sizeof(struct trace));
cur_trace = trace; cur_trace = trace;

8
src/emu/emu_trace.h → src/emu/trace.h
View File

@ -4,17 +4,17 @@
#ifndef EMU_TRACE_H #ifndef EMU_TRACE_H
#define EMU_TRACE_H #define EMU_TRACE_H
#include "emu_stream.h" #include "stream.h"
#include <linux/limits.h> #include <linux/limits.h>
struct emu_trace { struct trace {
char tracedir[PATH_MAX]; char tracedir[PATH_MAX];
long nstreams; long nstreams;
struct emu_stream *streams; struct stream *streams;
}; };
int emu_trace_load(struct emu_trace *trace, const char *tracedir); int trace_load(struct trace *trace, const char *tracedir);
#endif /* EMU_TRACE_H */ #endif /* EMU_TRACE_H */

4
test/unit/CMakeLists.txt
View File

@ -15,10 +15,10 @@ unit_test(mux.c)
unit_test(value.c) unit_test(value.c)
unit_test(prv.c) unit_test(prv.c)
#unit_test(ovni_model.c) #unit_test(ovni_model.c)
unit_test(emu_trace.c) unit_test(trace.c)
unit_test(emu.c) unit_test(emu.c)
unit_test(clkoff.c) unit_test(clkoff.c)
unit_test(emu_stream.c) unit_test(stream.c)
unit_test(loom.c) unit_test(loom.c)
unit_test(thread.c) unit_test(thread.c)
unit_test(proc.c) unit_test(proc.c)

14
test/unit/emu_trace.c
View File

@ -1,14 +0,0 @@
#include "emu/emu_trace.h"
#include "common.h"
int main(void)
{
char *tracedir = "/home/ram/bsc/ovni/traces/test/ovni";
struct emu_trace trace;
if (emu_trace_load(&trace, tracedir) != 0)
die("emu_trace_load failed\n");
return 0;
}

12
test/unit/emu_stream.c → test/unit/stream.c
View File

@ -24,10 +24,10 @@ test_ok(char *fname)
fclose(f); fclose(f);
struct emu_stream stream; struct stream stream;
const char *relpath = &fname[5]; const char *relpath = &fname[5];
if (emu_stream_load(&stream, "/tmp", relpath) != 0) if (stream_load(&stream, "/tmp", relpath) != 0)
die("emu_stream_load failed"); die("stream_load failed");
if (stream.active) if (stream.active)
die("stream is active\n"); die("stream is active\n");
@ -51,10 +51,10 @@ test_bad(char *fname)
fclose(f); fclose(f);
struct emu_stream stream; struct stream stream;
const char *relpath = &fname[5]; const char *relpath = &fname[5];
if (emu_stream_load(&stream, "/tmp", relpath) == 0) if (stream_load(&stream, "/tmp", relpath) == 0)
die("emu_stream_load didn't fail"); die("stream_load didn't fail");
} }
int main(void) int main(void)

14
test/unit/trace.c Normal file
View File

@ -0,0 +1,14 @@
#include "emu/trace.h"
#include "common.h"
int main(void)
{
char *tracedir = "/home/ram/bsc/ovni/traces/test/ovni";
struct trace trace;
if (trace_load(&trace, tracedir) != 0)
die("trace_load failed\n");
return 0;
}