static Token* stack_prevprev(QUEUE *stack)
{
QUEUE *p = QUEUE_PREV(stack);
p = QUEUE_PREV(p);
queue_item *item = queue_node_data(p);
return &item->item;
}
static Token stack_pop(QUEUE *stack)
{
QUEUE *h = QUEUE_HEAD(stack);
queue_item *item = queue_node_data(h);
QUEUE_REMOVE(&item->node);
Token token = item->item;
free(item);
return token;
}
static Event queue_pop(Queue *queue)
{
QUEUE *h = QUEUE_HEAD(&queue->headtail);
queue_item *item = queue_node_data(h);
QUEUE_REMOVE(&item->node);
Event e;
e = item->item;
free(item);
return e;
}
HOT successor_container fill_queue_recursive(group & g, successor_container const & successors_from_parent, size_t previous_activation_limit)
{
assert (g.has_synth_children());
typedef server_node_list::reverse_iterator r_iterator;
successor_container successors(successors_from_parent);
size_t children = g.child_count();
sequential_child_list sequential_children;
sequential_children.reserve(g.child_synth_count);
for (r_iterator it = g.child_nodes.rbegin(); it != g.child_nodes.rend(); ++it) {
server_node & node = *it;
if (node.is_synth()) {
r_iterator end_of_node = it;
--end_of_node; // one element behind the last
std::size_t node_count = 1;
// we fill the child nodes in reverse order to an array
for(;;) {
sequential_children.push_back(&*it);
++it;
if (it == g.child_nodes.rend())
break; // we found the beginning of this group
if (!it->is_synth())
break; // we hit a child group, later we may want to add it's nodes, too?
++node_count;
}
--it; // we iterated one element too far, so we need to go back to the previous element
assert(sequential_children.size() == node_count);
auto seq_it = sequential_children.rbegin();
int activation_limit = get_previous_activation_count(it, g.child_nodes.rend(), previous_activation_limit);
thread_queue_item * q_item =
q->allocate_queue_item(queue_node(std::move(queue_node_data(static_cast<abstract_synth*>(*seq_it++))), node_count),
successors, activation_limit);
queue_node & q_node = q_item->get_job();
// now we can add all nodes sequentially
for(;seq_it != sequential_children.rend(); ++seq_it)
q_node.add_node(static_cast<abstract_synth*>(*seq_it));
sequential_children.clear();
assert(q_node.size() == node_count);
/* advance successor list */
successors = successor_container(1);
successors[0] = q_item;
if (activation_limit == 0)
q->add_initially_runnable(q_item);
children -= node_count;
} else {
abstract_group & grp = static_cast<abstract_group&>(node);
if (grp.has_synth_children()) {
int activation_limit = get_previous_activation_count(it, g.child_nodes.rend(), previous_activation_limit);
successors = fill_queue_recursive(grp, successors, activation_limit);
}
children -= 1;
}
}
assert(children == 0);
return successors;
}
HOT successor_container fill_queue_recursive(parallel_group & g, successor_container const & successors_from_parent, size_t previous_activation_limit)
{
assert (g.has_synth_children());
std::vector<thread_queue_item*, rt_pool_allocator<thread_queue_item*> > collected_nodes;
collected_nodes.reserve(g.child_synth_count + g.child_group_count * 16); // pessimize
for (auto & node : g.child_nodes) {
if (node.is_synth()) {
thread_queue_item * q_item = q->allocate_queue_item(queue_node(std::move(queue_node_data(static_cast<abstract_synth*>(&node)))),
successors_from_parent, previous_activation_limit);
if (previous_activation_limit == 0)
q->add_initially_runnable(q_item);
collected_nodes.push_back(q_item);
} else {
abstract_group & grp = static_cast<abstract_group&>(node);
if (grp.has_synth_children()) {
successor_container group_successors = fill_queue_recursive(grp, successors_from_parent,
previous_activation_limit);
for (unsigned int i = 0; i != group_successors.size(); ++i)
collected_nodes.push_back(group_successors[i]);
}
}
}
successor_container ret(collected_nodes.size());
memcpy(ret.data->content, collected_nodes.data(), collected_nodes.size() * sizeof(thread_queue_item *));
return ret;
}
static Token* stack_head(QUEUE *stack)
{
QUEUE *h = QUEUE_HEAD(stack);
queue_item *item = queue_node_data(h);
return &item->item;
}
