Lines Matching refs:current

238             reserving_port_operation *current;
241                 current = op_list;
243                 switch(current->type) {
246                     my_predecessors.add(*(current->my_pred));
250                     current->status.store( SUCCEEDED, std::memory_order_release);
254                         my_predecessors.remove(*(current->my_pred));
259                     current->status.store( SUCCEEDED, std::memory_order_release );
263                         current->status.store( FAILED, std::memory_order_release);
265                     else if ( my_predecessors.try_reserve( *(current->my_arg) ) ) {
267                         current->status.store( SUCCEEDED, std::memory_order_release);
272                         current->status.store( FAILED, std::memory_order_release);
278                     current->status.store( SUCCEEDED, std::memory_order_release);
283                     current->status.store( SUCCEEDED, std::memory_order_release);
406             queueing_port_operation *current;
409                 current = op_list;
411                 switch(current->type) {
415                         this->push_back(current->my_val);
419                         current->bypass_t = rtask;
420                         current->status.store( SUCCEEDED, std::memory_order_release);
425                         __TBB_ASSERT(current->my_arg, nullptr);
426                         *(current->my_arg) = this->front();
427                         current->status.store( SUCCEEDED, std::memory_order_release);
430                         current->status.store( FAILED, std::memory_order_release);
439                     current->status.store( SUCCEEDED, std::memory_order_release);
564             key_matching_port_operation *current;
566                 current = op_list;
568                 switch(current->type) {
570                         bool was_inserted = this->insert_with_key(current->my_val);
572 …              current->status.store( was_inserted ? SUCCEEDED : FAILED, std::memory_order_release);
577                     __TBB_ASSERT(current->my_arg, nullptr);
578                     if(!this->find_with_key(my_join->current_key, *(current->my_arg))) {
581                     current->status.store( SUCCEEDED, std::memory_order_release);
586                     current->status.store( SUCCEEDED, std::memory_order_release);
903             key_matching_FE_operation *current;
905                 current = op_list;
907                 switch(current->type) {
911                         current->status.store( SUCCEEDED, std::memory_order_release);
916                         unref_key_type &t = current->my_val;
926                             current->bypass_t = fill_output_buffer(t);
929                     current->status.store( SUCCEEDED, std::memory_order_release);
932 …      current->status.store( this->buffer_empty() ? FAILED : SUCCEEDED, std::memory_order_release);
936                         current->status.store( FAILED, std::memory_order_release);
939                         *(current->my_output) = this->front();
940                         current->status.store( SUCCEEDED, std::memory_order_release);
1068             join_node_base_operation *current;
1070                 current = op_list;
1072                 switch(current->type) {
1074                         my_successors.register_successor(*(current->my_succ));
1083                         current->status.store( SUCCEEDED, std::memory_order_release);
1087                     my_successors.remove_successor(*(current->my_succ));
1088                     current->status.store( SUCCEEDED, std::memory_order_release);
1092                         if(try_to_make_tuple(*(current->my_arg))) {
1094                             current->status.store( SUCCEEDED, std::memory_order_release);
1096                         else current->status.store( FAILED, std::memory_order_release);
1098                     else current->status.store( FAILED, std::memory_order_release);
1127                         current->bypass_t = last_task;
1128                         current->status.store( SUCCEEDED, std::memory_order_release);