Inheritance diagram for Bio::EnsEMBL::Hive::Analysis:

Public Member Functions
public	unikey ()

public	logic_name ()

public	name ()

public	module ()

public	language ()

public	parameters ()

public	comment ()

public	tags ()

public	failed_job_tolerance ()

public	max_retry_count ()

public	can_be_empty ()

public	priority ()

public	meadow_type ()

public	analysis_capacity ()

public	hive_capacity ()

public	batch_size ()

public	get_compiled_module_name ()

public	url_query_params ()

public	display_name ()

public Bio::EnsEMBL::Hive::AnalysisStats	stats ()

public	status ()

public	jobs_collection ()

public	control_rules_collection ()

public	dataflow_rules_collection ()

public Listref	get_grouped_dataflow_rules ()

public	dataflow_rules_by_branch ()

public	dataflow ()

public	toString ()

public	print_diagram_node ()

Public Member Functions inherited from Bio::EnsEMBL::Hive::Storable
public Bio::EnsEMBL::Hive::Storable	new ()

public Int	dbID ()

public Bio::EnsEMBL::Hive::DBSQL::BaseAdaptor	adaptor ()

public	DESTROY ()

public	AUTOLOAD ()

Public Member Functions inherited from Bio::EnsEMBL::Hive::Cacheable
public	hive_pipeline ()

public	is_local_to ()

public	count_local_and_remote_objects ()

public	relative_display_name ()

public	relative_url ()

public	display_name ()

public	unikey ()

Detailed Description

Description

    An Analysis object represents a "stage" of the Hive pipeline that groups together
    all jobs that share the same module and the same common parameters.

    Individual Jobs are said to "belong" to an Analysis.

    Control rules unblock when their condition Analyses are done.

Definition at line 18 of file Analysis.pm.

Member Function Documentation

◆ analysis_capacity()

public Bio::EnsEMBL::Hive::Analysis::analysis_capacity ( )

Undocumented method

Code:

click to view

◆ batch_size()

public Bio::EnsEMBL::Hive::Analysis::batch_size ( )

Undocumented method

Code:

click to view

◆ can_be_empty()

public Bio::EnsEMBL::Hive::Analysis::can_be_empty ( )

Undocumented method

Code:

click to view

◆ comment()

public Bio::EnsEMBL::Hive::Analysis::comment ( )

Undocumented method

Code:

click to view

◆ control_rules_collection()

public Bio::EnsEMBL::Hive::Analysis::control_rules_collection ( )

Undocumented method

Code:

click to view

◆ dataflow()

public Bio::EnsEMBL::Hive::Analysis::dataflow ( )

Undocumented method

Code:

click to view

sub dataflow {
    my ( $self, $output_ids_for_this_rule, $emitting_job, $same_db_dataflow, $push_emitting_job_on_stack, $df_rule ) = @_;
 
    my $param_id_stack      = '';
    my $accu_id_stack       = '';
    my $emitting_job_id     = undef;
 
    if($same_db_dataflow) {
        $param_id_stack     = $emitting_job->param_id_stack;
        $accu_id_stack      = $emitting_job->accu_id_stack;
        $emitting_job_id    = $emitting_job->dbID;
 
        if($push_emitting_job_on_stack) {
            my $input_id        = $emitting_job->input_id;
            my $accu_hash       = $emitting_job->accu_hash;
 
            if($input_id and ($input_id ne '{}')) {     # add the parent to the param_id_stack if it had non-trivial extra parameters
                $param_id_stack = ($param_id_stack ? $param_id_stack.',' : '').$emitting_job_id;
            }
            if(scalar(keys %$accu_hash)) {    # add the parent to the accu_id_stack if it had "own" accumulator
                $accu_id_stack = ($accu_id_stack ? $accu_id_stack.',' : '').$emitting_job_id;
            }
        }
    }
 
    my $common_params = [
        'prev_job'          => $emitting_job,
        'analysis'          => $self,
        'hive_pipeline'     => $self->hive_pipeline,    # Although we may not cache jobs, make sure a new Job "belongs" to the same pipeline as its Analysis
        'param_id_stack'    => $param_id_stack,
        'accu_id_stack'     => $accu_id_stack,
    ];
 
    my $job_adaptor     = $self->adaptor->db->get_AnalysisJobAdaptor;
    my @output_job_ids  = ();
 
    if( my $funnel_dataflow_rule = $df_rule->funnel_dataflow_rule ) {    # members of a semaphored fan will have to wait in cache until the funnel is created:
 
        my $fan_cache_this_branch = $emitting_job->fan_cache->{"$funnel_dataflow_rule"} ||= [];
        push @$fan_cache_this_branch, map { Bio::EnsEMBL::Hive::AnalysisJob->new(
                                                @$common_params,
                                                'input_id'              => $_,
                                                # controlled_semaphore  => to be set when the $controlled_semaphore has been stored
                                            ) } @$output_ids_for_this_rule;
 
    } else {    # either a semaphored funnel or a non-semaphored dataflow:
 
        my $fan_jobs = delete $emitting_job->fan_cache->{"$df_rule"};   # clear the cache at the same time
 
        if( $fan_jobs && @$fan_jobs ) { # a semaphored funnel
 
            if( (my $funnel_job_count = scalar(@$output_ids_for_this_rule)) !=1 ) {
 
                $emitting_job->transient_error(0);
                die "Asked to dataflow into $funnel_job_count funnel jobs instead of 1";
 
            } else {
                my $funnel_job = Bio::EnsEMBL::Hive::AnalysisJob->new(
                    @$common_params,
                    'input_id'          => $output_ids_for_this_rule->[0],
                    'status'            => 'SEMAPHORED',
                );
 
                    # NB: $job_adaptor happens to belong to the $funnel_job, but not necesarily to $fan_jobs or $emitting_job
                my ($semaphore_id, $funnel_job_id, @fan_job_ids) = $job_adaptor->store_a_semaphored_group_of_jobs( $funnel_job, $fan_jobs, $emitting_job );
 
                push @output_job_ids, $funnel_job_id, @fan_job_ids;
            }
        } else {    # non-semaphored dataflow (but potentially propagating any existing semaphores)
            my @non_semaphored_jobs = map { Bio::EnsEMBL::Hive::AnalysisJob->new(
                                                @$common_params,
                                                'input_id'              => $_,
                                                'controlled_semaphore'  => $emitting_job->controlled_semaphore,     # propagate parent's semaphore if any
            ) } @$output_ids_for_this_rule;
 
                # NB: $job_adaptor happens to belong to the @non_semaphored_jobs, but not necessarily to the $emitting_job :
            push @output_job_ids, @{ $job_adaptor->store_jobs_and_adjust_counters( \@non_semaphored_jobs, 0, $emitting_job_id) };
        }
    } # /if funnel
 
    return \@output_job_ids;
}

◆ dataflow_rules_by_branch()

public Bio::EnsEMBL::Hive::Analysis::dataflow_rules_by_branch ( )

Undocumented method

Code:

click to view

◆ dataflow_rules_collection()

public Bio::EnsEMBL::Hive::Analysis::dataflow_rules_collection ( )

Undocumented method

Code:

click to view

◆ display_name()

public Bio::EnsEMBL::Hive::Analysis::display_name ( )

Undocumented method

Code:

click to view

◆ failed_job_tolerance()

public Bio::EnsEMBL::Hive::Analysis::failed_job_tolerance ( )

Undocumented method

Code:

click to view

◆ get_compiled_module_name()

public Bio::EnsEMBL::Hive::Analysis::get_compiled_module_name ( )

Undocumented method

Code:

click to view

◆ get_grouped_dataflow_rules()

public Listref Bio::EnsEMBL::Hive::Analysis::get_grouped_dataflow_rules ( )

  Args       : none
  Example    :

$groups = $analysis->get_grouped_dataflow_rules;

  Description: returns a listref of pairs, where the first element is a separate dfr or a funnel, and the second element is a listref of semaphored fan dfrs
  Returntype : listref

Code:

click to view

sub get_grouped_dataflow_rules {
    my $self = shift @_;
 
    my %set_of_groups = ();     # Note that the key (being a stringified reference) is unusable,
                                # so we end up packing it as the first element of the structure,
                                # and only returning the listref of the values.
    my @ordered_keys  = ();     # Perl is missing an "Ordered Hash" structure, so we need to maintain the insertion order ourselves
 
    my $all_dataflow_rules      = $self->dataflow_rules_collection;
 
    foreach my $dfr ((grep {$_->funnel_dataflow_rule} @$all_dataflow_rules), (grep {!$_->funnel_dataflow_rule} @$all_dataflow_rules)) {
 
        my $df_targets = $dfr->get_my_targets;
 
        if(my $funnel_dfr = $dfr->funnel_dataflow_rule) {
            unless($set_of_groups{$funnel_dfr}) {   # both the type check and the initial push will only be done once per funnel
                my $funnel_targets = $funnel_dfr->get_my_targets;
                foreach my $funnel_target (@$funnel_targets) {
                    unless($funnel_target->to_analysis->isa('Bio::EnsEMBL::Hive::Analysis')) {
                        throw("Each conditional branch of a semaphored funnel rule must point at an Analysis");
                    }
                }
                push @ordered_keys, $funnel_dfr;
                $set_of_groups{$funnel_dfr} = [$funnel_dfr, [], $funnel_targets];
            }
            my $this_group = $set_of_groups{$funnel_dfr};
 
            foreach my $df_target (@$df_targets) {
                unless($df_target->to_analysis->isa('Bio::EnsEMBL::Hive::Analysis')) {
                    throw("Each conditional branch of a semaphored fan rule must point at an Analysis");
                }
            }
            push @{$this_group->[1]}, $dfr;
 
        } elsif (!$set_of_groups{$dfr}) {
            push @ordered_keys, $dfr;
            $set_of_groups{$dfr} = [$dfr, [], $df_targets];
        }
    }
    my @sorted_rules = sort { scalar(@{$set_of_groups{$a}->[1]}) <=> scalar(@{$set_of_groups{$b}->[1]}) or $set_of_groups{$a}->[0]->branch_code <=> $set_of_groups{$b}->[0]->branch_code } @ordered_keys;
    return [map {$set_of_groups{$_}} @sorted_rules];
}

◆ hive_capacity()

public Bio::EnsEMBL::Hive::Analysis::hive_capacity ( )

Undocumented method

Code:

click to view

◆ jobs_collection()

public Bio::EnsEMBL::Hive::Analysis::jobs_collection ( )

Undocumented method

Code:

click to view

◆ language()

public Bio::EnsEMBL::Hive::Analysis::language ( )

Undocumented method

Code:

click to view

◆ logic_name()

public Bio::EnsEMBL::Hive::Analysis::logic_name ( )

Undocumented method

Code:

click to view

◆ max_retry_count()

public Bio::EnsEMBL::Hive::Analysis::max_retry_count ( )

Undocumented method

Code:

click to view

◆ meadow_type()

public Bio::EnsEMBL::Hive::Analysis::meadow_type ( )

Undocumented method

Code:

click to view

◆ module()

public Bio::EnsEMBL::Hive::Analysis::module ( )

Undocumented method

Code:

click to view

◆ name()

public Bio::EnsEMBL::Hive::Analysis::name ( )

Undocumented method

Code:

click to view

◆ parameters()

public Bio::EnsEMBL::Hive::Analysis::parameters ( )

Undocumented method

Code:

click to view

◆ print_diagram_node()

public Bio::EnsEMBL::Hive::Analysis::print_diagram_node ( )

Undocumented method

Code:

click to view

sub print_diagram_node {
    my ($self, $ref_pipeline, $prefix, $seen_analyses) = @_;
 
    if($seen_analyses->{$self}++) {
        print "(".$self->relative_display_name($ref_pipeline).")\n";  # NB: the prefix of the label itself is done by the previous level
        return;
    }
 
    print $self->relative_display_name($ref_pipeline)."\n";  # NB: the prefix of the label itself is done by the previous level
 
    my $groups = $self->get_grouped_dataflow_rules;
 
    foreach my $i (0..scalar(@$groups)-1) {
 
        my ($funnel_dfr, $fan_dfrs, $df_targets) = @{ $groups->[$i] };
 
        my $this_funnel_offset  = '';
 
        if(scalar(@$groups)>1 and scalar(@$fan_dfrs)) {     # if more than one group (no single backbone) and semaphored, the semaphored group will be offset:
            print $prefix." │\n";
            print $prefix." ╘════╤══╗\n";   # " └────┬──┐\n";
            $this_funnel_offset = ($i < scalar(@$groups)-1) ? ' │   ' : '     ';    # non-last vs last group
        }
 
        foreach my $j (0..scalar(@$fan_dfrs)-1) {   # for each of the dependent fan rules, show them one by one:
            my $fan_dfr     = $fan_dfrs->[$j];
            my $fan_branch  = $fan_dfr->branch_code;
 
            print $prefix.$this_funnel_offset." │  ║\n";
            print $prefix.$this_funnel_offset." │  ║\n";
            print $prefix.$this_funnel_offset." │  ║#$fan_branch\n";
 
            my $fan_df_targets = $fan_dfr->get_my_targets;
 
            foreach my $k (0..scalar(@$fan_df_targets)-1) {   # for each fan's target
                my $fan_target = $fan_df_targets->[$k];
 
                print $prefix.$this_funnel_offset." │  ║\n";
 
                if(my $fan_choice = (scalar(@$fan_df_targets)!=1) || defined($fan_target->on_condition)) {
                    if(defined(my $on_condition = $fan_target->on_condition)) {
                        print $prefix.$this_funnel_offset." │  ║ WHEN $on_condition\n";
                    } else {
                        print $prefix.$this_funnel_offset." │  ║ ELSE\n";
                    }
                }
                print $prefix.$this_funnel_offset.' │├─╚═> ';
 
                my $next_fan_or_condition_offset = ($j<scalar(@$fan_dfrs)-1 or $k<scalar(@$fan_df_targets)-1) ? ' │  ║   ' : ' │      ';
 
                if(my $template = $fan_target->input_id_template) {
                    print "$template\n";
                    print $prefix.$this_funnel_offset.$next_fan_or_condition_offset." │\n";
                    print $prefix.$this_funnel_offset.$next_fan_or_condition_offset." V\n";
                    print $prefix.$this_funnel_offset.$next_fan_or_condition_offset;
                }
 
                $fan_target->to_analysis->print_diagram_node($ref_pipeline, $prefix.$this_funnel_offset.$next_fan_or_condition_offset, $seen_analyses );
            }
        }
 
        my $funnel_branch   = $funnel_dfr->branch_code;
 
        print $prefix.$this_funnel_offset." │\n";
        print $prefix.$this_funnel_offset." │\n";
        print $prefix.$this_funnel_offset." │#$funnel_branch\n";
 
        foreach my $k (0..scalar(@$df_targets)-1) {   # for each funnel's target
            my $df_target = $df_targets->[$k];
 
            print $prefix.$this_funnel_offset." │\n";
 
            my $funnel_choice = (scalar(@$df_targets)!=1) || defined($df_target->on_condition);
 
            if($funnel_choice) {
                if(defined(my $on_condition = $df_target->on_condition)) {
                    print $prefix.$this_funnel_offset." │ WHEN $on_condition\n";
                } else {
                    print $prefix.$this_funnel_offset." │ ELSE\n";
                }
            }
 
            my $next_funnel_or_condition_offset = '';
 
            if( (scalar(@$groups)==1 or $this_funnel_offset) and !$funnel_choice ) {  # 'the only group' (backbone) or a semaphore funnel ...
                print $prefix.$this_funnel_offset." V\n";       # ... make a vertical arrow
                print $prefix.$this_funnel_offset;
            } else {
                print $prefix.$this_funnel_offset.' └─▻ ';      # otherwise fork to the right
                $next_funnel_or_condition_offset = ($i<scalar(@$groups)-1 or $k<scalar(@$df_targets)-1) ? ' │  ' : '    ';
            }
            if(my $template = $df_target->input_id_template) {
                print "$template\n";
                print $prefix.$this_funnel_offset.$next_funnel_or_condition_offset." │\n";
                print $prefix.$this_funnel_offset.$next_funnel_or_condition_offset." V\n";
                print $prefix.$this_funnel_offset.$next_funnel_or_condition_offset;
            }
 
            my $target = $df_target->to_analysis;
            if($target->can('print_diagram_node')) {
                $target->print_diagram_node($ref_pipeline, $prefix.$this_funnel_offset.$next_funnel_or_condition_offset, $seen_analyses );
            } elsif($target->isa('Bio::EnsEMBL::Hive::NakedTable')) {
                print '[[ '.$target->relative_display_name($ref_pipeline)." ]]\n";
            } elsif($target->isa('Bio::EnsEMBL::Hive::Accumulator')) {
                print '<<-- '.$target->relative_display_name($ref_pipeline)."\n";
            }
        }
    }
}

◆ priority()

public Bio::EnsEMBL::Hive::Analysis::priority ( )

Undocumented method

Code:

click to view

◆ stats()

public Bio::EnsEMBL::Hive::AnalysisStats Bio::EnsEMBL::Hive::Analysis::stats ( )

  Arg [1]    : none
  Example    :

$stats = $analysis->stats;

  Description: returns either the previously cached AnalysisStats object, or if it is missing - pulls a fresh one from the DB.
  Returntype : Bio::EnsEMBL::Hive::AnalysisStats object
  Exceptions : none
  Caller     : general

Code:

click to view

◆ status()

public Bio::EnsEMBL::Hive::Analysis::status ( )

Undocumented method

Code:

click to view

◆ tags()

public Bio::EnsEMBL::Hive::Analysis::tags ( )

Undocumented method

Code:

click to view

◆ toString()

public Bio::EnsEMBL::Hive::Analysis::toString ( )

Undocumented method

Code:

click to view

◆ unikey()

public Bio::EnsEMBL::Hive::Analysis::unikey ( )

Undocumented method

Code:

click to view

◆ url_query_params()

public Bio::EnsEMBL::Hive::Analysis::url_query_params ( )

Undocumented method

Code:

click to view

The documentation for this class was generated from the following file:

modules/Bio/EnsEMBL/Hive/Analysis.pm

Public Member Functions

Detailed Description

Description

Member Function Documentation

◆ analysis_capacity()

◆ batch_size()

◆ can_be_empty()

◆ comment()

◆ control_rules_collection()

◆ dataflow()

◆ dataflow_rules_by_branch()

◆ dataflow_rules_collection()

◆ display_name()

◆ failed_job_tolerance()

◆ get_compiled_module_name()

◆ get_grouped_dataflow_rules()

◆ hive_capacity()

◆ jobs_collection()

◆ language()

◆ logic_name()

◆ max_retry_count()

◆ meadow_type()

◆ module()

◆ name()

◆ parameters()

◆ print_diagram_node()

◆ priority()

◆ stats()

◆ status()

◆ tags()

◆ toString()

◆ unikey()

◆ url_query_params()