Mirrors/VILLASnode
1
0
Fork 0
mirror of https://git.rwth-aachen.de/acs/public/villas/node/ synced 2025-03-09 00:00:00 +01:00
Code Issues Releases Wiki Activity

pipe: move pool management into Direction class

Browse source
This commit is contained in:
Steffen Vogel 2018-12-02 03:09:09 +01:00
parent 3a45ae3b3d
commit 7a40af8009
1 changed files with 38 additions and 44 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

82
src/villas-pipe.cpp
View file

@ -54,17 +54,36 @@ using namespace villas::node;
class Direction {
public:
Direction(struct io *i) :
Direction(struct node *n, struct io *i, bool en = true, int lim = -1) :
node(n),
io(i),
enabled(true),
limit(-1)
{ }
enabled(en),
limit(lim)
{
pool.state = STATE_DESTROYED;
pool.queue.state = STATE_DESTROYED;
/* Initialize memory */
/* Initialize memory */
unsigned pool_size = node_type(node)->pool_size ? node_type(node)->pool_size : LOG2_CEIL(node->out.vectorize);
int ret = pool_init(&pool, pool_size, SAMPLE_LENGTH(DEFAULT_SAMPLE_LENGTH), node_memory_type(node, &memory_hugepage));
if (ret < 0)
throw RuntimeError("Failed to allocate memory for pool.");
}
Direction(const Direction &c)
{
io = c.io;
}
~Direction()
{
pool_destroy(&pool);
}
struct pool pool;
struct node *node;
struct io *io;
@ -123,14 +142,6 @@ static void * send_loop(void *ctx)
struct sample *smps[dirs->send.node->out.vectorize];
/* Initialize memory */
unsigned pool_size = node_type(dirs->send.node)->pool_size ? node_type(dirs->send.node)->pool_size : LOG2_CEIL(dirs->send.node->out.vectorize);
ret = pool_init(&dirs->send.pool, pool_size, SAMPLE_LENGTH(DEFAULT_SAMPLE_LENGTH), node_memory_type(dirs->send.node, &memory_hugepage));
if (ret < 0)
throw new RuntimeError("Failed to allocate memory for receive pool.");
while (!io_eof(dirs->send.io)) {
allocated = sample_alloc_many(&dirs->send.pool, smps, dirs->send.node->out.vectorize);
if (ret < 0)
@ -192,18 +203,10 @@ static void * recv_loop(void *ctx)
Directions *dirs = static_cast<Directions*>(ctx);
Logger logger = logging.get("pipe");
int recv, ret, cnt = 0, allocated = 0;
int recv, cnt = 0, allocated = 0;
unsigned release;
struct sample *smps[dirs->recv.node->in.vectorize];
/* Initialize memory */
unsigned pool_size = node_type(dirs->recv.node)->pool_size ? node_type(dirs->recv.node)->pool_size : LOG2_CEIL(dirs->recv.node->in.vectorize);
ret = pool_init(&dirs->recv.pool, pool_size, SAMPLE_LENGTH(list_length(&dirs->recv.node->signals)), node_memory_type(dirs->recv.node, &memory_hugepage));
if (ret < 0)
throw new RuntimeError("Failed to allocate memory for receive pool.");
for (;;) {
allocated = sample_alloc_many(&dirs->recv.pool, smps, dirs->recv.node->in.vectorize);
if (allocated < 0)
@ -243,16 +246,14 @@ int main(int argc, char *argv[])
struct node *node;
static struct io io = { .state = STATE_DESTROYED };
Directions dirs = {
.send = Direction(&io),
.recv = Direction(&io)
};
SuperNode sn; /**< The global configuration */
Logger logger = logging.get("pipe");
json_t *cfg_cli = json_object();
bool enable_send = true, enable_recv = true;
int limit_send = -1, limit_recv = -1;
int c;
char *endptr;
while ((c = getopt(argc, argv, "Vhxrsd:l:L:t:f:o:")) != -1) {
@ -270,19 +271,19 @@ int main(int argc, char *argv[])
break;
case 's':
dirs.recv.enabled = false; // send only
enable_recv = false; // send only
break;
case 'r':
dirs.send.enabled = false; // receive only
enable_send = false; // receive only
break;
case 'l':
dirs.recv.limit = strtoul(optarg, &endptr, 10);
limit_recv = strtoul(optarg, &endptr, 10);
goto check;
case 'L':
dirs.send.limit = strtoul(optarg, &endptr, 10);
limit_send = strtoul(optarg, &endptr, 10);
goto check;
case 't':
@ -316,7 +317,7 @@ check: if (optarg == endptr)
exit(EXIT_FAILURE);
}
info("Logging level: %d", logging.getLevel());
logger->info("Logging level: {}", logging.getLevelName());
char *uri = argv[optind];
char *nodestr = argv[optind+1];
@ -385,6 +386,11 @@ check: if (optarg == endptr)
throw RuntimeError("Failed to start node {}: reason={}", node_name(node), ret);
/* Start threads */
Directions dirs = {
.send = Direction(node, &io, enable_send, limit_send),
.recv = Direction(node, &io, enable_recv, limit_recv)
};
if (dirs.recv.enabled) {
dirs.recv.node = node;
pthread_create(&dirs.recv.thread, nullptr, recv_loop, &dirs);
@ -416,19 +422,7 @@ check: if (optarg == endptr)
ret = node_type_stop(node->_vt);
if (ret)
throw new RuntimeError("Failed to stop node type {}: reason={}", node_type_name(node->_vt), ret);
if (dirs.recv.enabled) {
ret = pool_destroy(&dirs.recv.pool);
if (ret)
throw new RuntimeError("Failed to destroy pool");
}
if (dirs.send.enabled) {
ret = pool_destroy(&dirs.send.pool);
if (ret)
throw new RuntimeError("Failed to destroy pool");
}
throw RuntimeError("Failed to stop node type {}: reason={}", node_type_name(node->_vt), ret);
ret = io_close(&io);
if (ret)