static void
process_references (struct ipa_ref_list *list,
symtab_node *first,
bool before_inlining_p,
struct pointer_set_t *reachable)
{
int i;
struct ipa_ref *ref;
for (i = 0; ipa_ref_list_reference_iterate (list, i, ref); i++)
{
if (is_a <cgraph_node> (ref->referred))
{
struct cgraph_node *node = ipa_ref_node (ref);
if (node->analyzed
&& (!DECL_EXTERNAL (node->symbol.decl)
|| node->alias
|| before_inlining_p))
pointer_set_insert (reachable, node);
enqueue_node ((symtab_node) node, first, reachable);
}
else
{
struct varpool_node *node = ipa_ref_varpool_node (ref);
if (node->analyzed
&& (!DECL_EXTERNAL (node->symbol.decl)
|| node->alias
|| before_inlining_p))
pointer_set_insert (reachable, node);
enqueue_node ((symtab_node) node, first, reachable);
}
}
}
strict_fibonacci_node* pq_insert( strict_fibonacci_heap *queue, item_type item,
key_type key )
{
strict_fibonacci_node* wrapper = pq_alloc_node( queue->map,
STRICT_NODE_FIB );
ITEM_ASSIGN( wrapper->item, item );
wrapper->key = key;
wrapper->right = wrapper;
wrapper->left = wrapper;
wrapper->q_next = wrapper;
wrapper->q_prev = wrapper;
strict_fibonacci_node *parent, *child;
if( queue->root == NULL )
queue->root = wrapper;
else
{
choose_order_pair( wrapper, queue->root, &parent, &child );
link( queue, parent, child );
queue->root = parent;
enqueue_node( queue, child );
post_meld_reduction( queue );
}
queue->size++;
garbage_collection( queue );
return wrapper;
}
strict_fibonacci_heap* pq_meld( strict_fibonacci_heap *a,
strict_fibonacci_heap *b )
{
strict_fibonacci_heap *new_heap = pq_create( a->map );
strict_fibonacci_heap *big, *small;
strict_fibonacci_node *big_head, *big_tail, *small_head, *small_tail;
strict_fibonacci_node *parent, *child;
// pick which heap to preserve
if( a->size < b->size )
{
big = b;
small = a;
}
else
{
big = a;
small = b;
}
// set heap fields
new_heap->size = big->size + small->size;
new_heap->q_head = big->q_head;
new_heap->active = big->active;
new_heap->rank_list = big->rank_list;
new_heap->fix_list[0] = big->fix_list[0];
new_heap->fix_list[1] = big->fix_list[1];
if( small->active != NULL )
small->active->flag = 0;
// merge the queues
big_head = big->q_head;
big_tail = big_head->q_prev;
small_head = small->q_head;
small_tail = small_head->q_prev;
big_head->q_prev = small_tail;
small_tail->q_next = big_head;
small_head->q_prev = big_tail;
big_tail->q_next = small_head;
// actually link the two trees
choose_order_pair( big->root, small->root, &parent, &child );
link( new_heap, parent, child );
new_heap->root = parent;
enqueue_node( new_heap, child );
// take care of some garbage collection
release_to_garbage_collector( new_heap, small );
free( small );
free( big );
garbage_collection( new_heap );
return new_heap;
}
void pq_decrease_key( strict_fibonacci_heap *queue, strict_fibonacci_node *node,
key_type new_key )
{
strict_fibonacci_node *old_parent = node->parent;
node->key = new_key;
if( old_parent == NULL || node->key > old_parent->key)
return;
strict_fibonacci_node *parent, *child;
choose_order_pair( node, queue->root, &parent, &child );
link( queue, parent, child );
queue->root = parent;
queue->root->parent = NULL;
if( parent == node )
{
dequeue_node( queue, parent );
enqueue_node( queue, child );
}
if( is_active( queue, node ) )
{
if( is_active( queue, old_parent ) )
decrease_rank( queue, old_parent );
if( node->type != STRICT_TYPE_ROOT )
convert_active_to_root( queue, node );
}
if( is_active( queue, old_parent ) && old_parent->type != STRICT_TYPE_ROOT )
increase_loss( queue, old_parent );
post_decrease_key_reduction( queue );
garbage_collection( queue );
}
static void
varpool_remove_unreferenced_decls (void)
{
varpool_node *next, *node;
varpool_node *first = (varpool_node *)(void *)1;
int i;
struct ipa_ref *ref;
struct pointer_set_t *referenced = pointer_set_create ();
if (seen_error ())
return;
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "Trivially needed variables:");
FOR_EACH_DEFINED_VARIABLE (node)
{
if (node->analyzed
&& (!varpool_can_remove_if_no_refs (node)
/* We just expanded all function bodies. See if any of
them needed the variable. */
|| DECL_RTL_SET_P (node->decl)))
{
enqueue_node (node, &first);
if (cgraph_dump_file)
fprintf (cgraph_dump_file, " %s", node->asm_name ());
}
}
while (first != (varpool_node *)(void *)1)
{
node = first;
first = (varpool_node *)first->aux;
if (node->same_comdat_group)
{
symtab_node *next;
for (next = node->same_comdat_group;
next != node;
next = next->same_comdat_group)
{
varpool_node *vnext = dyn_cast <varpool_node *> (next);
if (vnext && vnext->analyzed && !symtab_comdat_local_p (next))
enqueue_node (vnext, &first);
}
}
for (i = 0; ipa_ref_list_reference_iterate (&node->ref_list, i, ref); i++)
{
varpool_node *vnode = dyn_cast <varpool_node *> (ref->referred);
if (vnode
&& !vnode->in_other_partition
&& (!DECL_EXTERNAL (ref->referred->decl)
|| vnode->alias)
&& vnode->analyzed)
enqueue_node (vnode, &first);
else
pointer_set_insert (referenced, node);
}
}
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "\nRemoving variables:");
for (node = varpool_first_defined_variable (); node; node = next)
{
next = varpool_next_defined_variable (node);
if (!node->aux)
{
if (cgraph_dump_file)
fprintf (cgraph_dump_file, " %s", node->asm_name ());
if (pointer_set_contains (referenced, node))
varpool_remove_initializer (node);
else
varpool_remove_node (node);
}
}
pointer_set_destroy (referenced);
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "\n");
}
void enqueue(const T &t) {
enqueue_node(new MSQueueNode(t));
}
void enqueue(T &&t) {
enqueue_node(new MSQueueNode(std::move(t)));
}
void sync_enqueue(actor* sender, message_id_t id, any_tuple msg) {
enqueue_node(super::fetch_node(sender, std::move(msg), id));
}
void enqueue(actor* sender, any_tuple msg) {
enqueue_node(super::fetch_node(sender, std::move(msg)));
}
bool chained_sync_enqueue(actor* sender,
message_id_t id,
any_tuple msg) {
return enqueue_node(super::fetch_node(sender, std::move(msg), id), pending);
}
bool chained_enqueue(actor* sender, any_tuple msg) {
return enqueue_node(super::fetch_node(sender, std::move(msg)), pending);
}
static void
varpool_remove_unreferenced_decls (void)
{
struct varpool_node *next, *node;
struct varpool_node *first = (struct varpool_node *)(void *)1;
int i;
struct ipa_ref *ref;
if (seen_error ())
return;
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "Trivially needed variables:");
FOR_EACH_DEFINED_VARIABLE (node)
{
if (node->analyzed
&& (!varpool_can_remove_if_no_refs (node)
/* We just expanded all function bodies. See if any of
them needed the variable. */
|| (!DECL_EXTERNAL (node->symbol.decl)
&& DECL_RTL_SET_P (node->symbol.decl))))
{
enqueue_node (node, &first);
if (cgraph_dump_file)
fprintf (cgraph_dump_file, " %s", varpool_node_asm_name (node));
}
}
while (first != (struct varpool_node *)(void *)1)
{
node = first;
first = (struct varpool_node *)first->symbol.aux;
if (node->symbol.same_comdat_group)
{
symtab_node next;
for (next = node->symbol.same_comdat_group;
next != (symtab_node)node;
next = next->symbol.same_comdat_group)
{
varpool_node *vnext = dyn_cast <varpool_node> (next);
if (vnext && vnext->analyzed)
enqueue_node (vnext, &first);
}
}
for (i = 0; ipa_ref_list_reference_iterate (&node->symbol.ref_list, i, ref); i++)
{
varpool_node *vnode = dyn_cast <varpool_node> (ref->referred);
if (vnode
&& (!DECL_EXTERNAL (ref->referred->symbol.decl)
|| vnode->alias)
&& vnode->analyzed)
enqueue_node (vnode, &first);
}
}
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "\nRemoving variables:");
for (node = varpool_first_defined_variable (); node; node = next)
{
next = varpool_next_defined_variable (node);
if (!node->symbol.aux)
{
if (cgraph_dump_file)
fprintf (cgraph_dump_file, " %s", varpool_node_asm_name (node));
varpool_remove_node (node);
}
}
if (cgraph_dump_file)
fprintf (cgraph_dump_file, "\n");
}
int main(void)
{
/* Declare YOUR variables here ! */
Stack mystack;
Queue myqueue;
int menu_choice;
srand((unsigned int)time(NULL));
if ((myqueue = QUEUEinit(my_destroy)) == NULL) /* Create new queue... */
{
printf("\nFatal error - bailing out...!");
QUEUEdestroy(myqueue);
exit(-1);
}
if ((mystack = STACKinit(my_destroy)) == NULL) /* Create new stack... */
{
printf("\nFatal error - bailing out...!");
STACKdestroy(mystack);
exit(-1);
}
/* Create and initialize queue and stack... */
enqueue_push_nodes(myqueue, mystack, NR_OF_ITEMS);
do
{
menu_choice = menu(MAIN_MENU_ROW, 0, 6);
switch (menu_choice)
{
case 1:
enqueue_node(myqueue);
break;
case 2:
dequeue_node(myqueue);
break;
case 3:
push_node(mystack);
break;
case 4:
pop_node(mystack);
break;
case 5:
dequeue_push_node(myqueue, mystack);
break;
case 6:
print_queue_stack(myqueue, mystack);
break;
default:
final_status(myqueue, mystack);
break;
}
}
while (menu_choice);
prompt_and_pause("\n\nLet's tidy up (destroy queue/stack)..- Bye!");
STACKdestroy(mystack);
QUEUEdestroy(myqueue);
return 0;
}
void abstract_scheduled_actor::enqueue(actor* sender, any_tuple const& msg)
{
enqueue_node(fetch_node(sender, msg));
//enqueue_node(new queue_node(sender, msg));
}
void abstract_scheduled_actor::enqueue(actor* sender, any_tuple&& msg)
{
enqueue_node(fetch_node(sender, std::move(msg)));
//enqueue_node(new queue_node(sender, std::move(msg)));
}
