def master_job(n_jobs, prefixes):

    t_tot = time.time()
    # submit jobs 1
    for prefix in prefixes:
        subprocess.call(['./jobs_step1_%s.sh' % prefix])
        # wait for jobs 1, only if we have a random forest
        failed_jobs = wait_and_check_multiple_jobs('consensus_stitching_step1_%s' % prefix, n_jobs)
        if failed_jobs:
            print("Step 1 %s failed for following jobs:" % prefix)
            print(failed_jobs)
            return

    # submit jobs 2
    subprocess.call(['./jobs_step2.sh'])
    # wait for jobs 2
    failed_jobs = wait_and_check_single_job('costs_step2')
    if failed_jobs:
        print("Step 2 failed")
        return

    subprocess.call(['./jobs_step3.sh'])
    # wait for jobs 1, only if we have a random forest
    failed_jobs = wait_and_check_multiple_jobs('consensus_stitching_step3', n_jobs)
    if failed_jobs:
        print("Step 3 failed for following jobs:")
        print(failed_jobs)
        return

    t_tot = time.time() - t_tot
    print("All jobs finished successfully in %f s" % t_tot)
Beispiel #2
0
def master_job(n_jobs):
    # submit jobs 1
    subprocess.call(['./jobs_step1.sh'])
    # wait for jobs 1
    failed_jobs = wait_and_check_multiple_jobs('watershed_step1', n_jobs)
    if failed_jobs:
        print("Step 1 failed for following jobs:")
        print(failed_jobs)
        return

    # submit jobs 2
    subprocess.call(['./jobs_step2.sh'])
    # wait for jobs 2
    failed_jobs = wait_and_check_multiple_jobs('watershed_step2', n_jobs)
    if failed_jobs:
        print("Step 2 failed for following jobs:")
        print(failed_jobs)
        return

    # submit jobs 3
    subprocess.call(['./jobs_step3.sh'])
    # wait for jobs 3
    failed_jobs = wait_and_check_single_job('watershed_step3')
    if failed_jobs:
        print("Step 3 failed")
        return

    # submit jobs 4
    subprocess.call(['./jobs_step4.sh'])
    # wait for jobs 4
    failed_jobs = wait_and_check_multiple_jobs('watershed_step4', n_jobs)
    if failed_jobs:
        print("Step 4 failed for following jobs:")
        print(failed_jobs)
        return
def master_job(n_jobs):

    t_tot = time.time()
    # submit jobs 1
    subprocess.call(['./jobs_step1.sh'])
    # wait for jobs 1
    failed_jobs = wait_and_check_multiple_jobs('relabel_step1', n_jobs)
    if failed_jobs:
        print("Step 1 failed for following jobs:")
        print(failed_jobs)
        return

    # submit jobs 2
    subprocess.call(['./jobs_step2.sh'])
    # wait for jobs 2
    failed_jobs = wait_and_check_single_job('relabel_step2')
    if failed_jobs:
        print("Step 2 failed for following jobs:")
        return

    # submit jobs 3
    subprocess.call(['./jobs_step3.sh'])
    # wait for jobs 3
    failed_jobs = wait_and_check_multiple_jobs('relabel_step3', n_jobs)
    if failed_jobs:
        print("Step 3 failed for following jobs")
        print(failed_jobs)
        return

    t_tot = time.time() - t_tot
    print("All jobs ran successfully in %f s" % t_tot)
def master_job(n_jobs, n_scales):

    t_tot = time.time()
    # submit jobs 1
    subprocess.call(['./jobs_step1.sh'])
    # wait for jobs 1
    failed_jobs = wait_and_check_multiple_jobs('graph_step1', n_jobs)
    if failed_jobs:
        print("Step 1 failed for following jobs:")
        print(failed_jobs)
        return

    # submit jobs 2 for scales 2:
    if n_scales > 1:
        for scale in range(1, n_scales):
            subprocess.call(['./jobs_step2_scale%i.sh' % scale])
            # wait for jobs 2
            failed_jobs = wait_and_check_multiple_jobs(
                'graph_step2_scale%i' % scale, n_jobs)
            if failed_jobs:
                print("Step 2, scale %i failed for following jobs:" % scale)
                print(failed_jobs)
                return

    # submit jobs 3
    subprocess.call(['./jobs_step3.sh'])
    # wait for jobs 3
    failed_jobs = wait_and_check_single_job('graph_step3')
    if failed_jobs:
        print("Step 3 failed")
        return

    # submit jobs 4
    subprocess.call(['./jobs_step4.sh'])
    # wait for jobs 4
    if n_scales == 1:
        failed_jobs = wait_and_check_single_job('graph_step4_scale0')
    else:
        failed_jobs = wait_and_check_multiple_jobnames(
            ['graph_step4_scale%i' % scale for scale in range(n_scales)],
            n_jobs)
    if failed_jobs:
        print("Step 4 failed for following jobs:")
        print(failed_jobs)
        return

    t_tot = time.time() - t_tot
    print("All jobs finished successfully in %f s" % t_tot)
def master_job(n_jobs):

    t_tot = time.time()
    # submit jobs 1
    subprocess.call(['./jobs_step1.sh'])
    # wait for jobs 1
    failed_jobs = wait_and_check_multiple_jobs('minfilter_step1', n_jobs)
    if failed_jobs:
        print("Step 1 failed for following jobs:")
        print(failed_jobs)
        return

    t_tot = time.time() - t_tot
    print("All jobs ran successfully in %f s" % t_tot)
def master_job(n_jobs1, n_jobs2):

    t_tot = time.time()
    # submit jobs 1
    subprocess.call(['./jobs_step1.sh'])
    # wait for jobs 1
    failed_jobs = wait_and_check_multiple_jobs('features_step1', n_jobs1)
    if failed_jobs:
        print("Step 1 failed for following jobs:")
        print(failed_jobs)
        return

    # submit jobs 2
    subprocess.call(['./jobs_step2.sh'])
    # wait for jobs 3
    failed_jobs = wait_and_check_multiple_jobs('features_step2', n_jobs2)
    if failed_jobs:
        print("Step 2 failed for following jobs:")
        print(failed_jobs)
        return

    t_tot = time.time() - t_tot
    print("All jobs finished successfully in %f s" % t_tot)
def master_job(n_jobs, n_scales):

    t_tot = time.time()
    # submit jobs 1
    subprocess.call(['./jobs_step1.sh'])
    # FIXME
    # # wait for jobs 1
    # failed_jobs = wait_and_check_single_job('multicut_step1', n_jobs)
    # if failed_jobs:
    #     print("Step 1 failed")
    #     return

    # submit jobs 2 for
    for scale in range(n_scales):
        subprocess.call(['./jobs_step2subproblem_scale%i.sh' % scale])
        # wait for subproblem extractions
        failed_jobs = wait_and_check_multiple_jobs(
            'multicut_step2_scale%i' % scale, n_jobs)
        if failed_jobs:
            print(
                "Step 2, scale %i, subproblem extraction failed for following jobs:"
                % scale)
            print(failed_jobs)
            return
        # schedule and wait for reduced problem
        subprocess.call(['./jobs_step2reduce_scale%i.sh' % scale])
        failed_jobs = wait_and_check_single_job('multicut_step2_scale%i' %
                                                scale)
        if failed_jobs:
            print("Step 2 failed, scale %i, reduce failed" % scale)
            return

    # submit jobs 3
    subprocess.call(['./jobs_step3.sh'])
    # wait for jobs 3
    failed_jobs = wait_and_check_single_job('multicut_step3')
    if failed_jobs:
        print("Step 3 failed")
        return

    t_tot = time.time() - t_tot
    print("All jobs finished successfully in %f s" % t_tot)
def master_job(n_jobs, with_rf):

    t_tot = time.time()
    # submit jobs 1
    subprocess.call(['./jobs_step1.sh'])
    # wait for jobs 1, only if we have a random forest
    if with_rf:
        failed_jobs = wait_and_check_multiple_jobs('costs_step1', n_jobs)
        if failed_jobs:
            print("Step 1 failed for following jobs:")
            print(failed_jobs)
            return

    # submit jobs 2
    subprocess.call(['./jobs_step2.sh'])
    # wait for jobs 3
    failed_jobs = wait_and_check_single_job('costs_step2')
    if failed_jobs:
        print("Step 2 failed")
        return

    t_tot = time.time() - t_tot
    print("All jobs finished successfully in %f s" % t_tot)
Beispiel #9
0
def master_job(n_jobs, have_ws_job):
    # submit jobs 0
    subprocess.call(['./jobs_step0.sh'])
    # wait for jobs 1
    failed_jobs = wait_and_check_single_job('dt_components_step0')
    if failed_jobs:
        print("Step 0 failed")
        return

    # submit jobs 1
    subprocess.call(['./jobs_step1.sh'])
    # wait for jobs 1
    failed_jobs = wait_and_check_multiple_jobs('dt_components_step1', n_jobs)
    if failed_jobs:
        print("Step 1 failed for following jobs:")
        print(failed_jobs)
        return

    # submit jobs 2
    subprocess.call(['./jobs_step2.sh'])
    # wait for jobs 2
    failed_jobs = wait_and_check_single_job('dt_components_step2')
    if failed_jobs:
        print("Step 2 failed")
        return

    # submit jobs 3
    subprocess.call(['./jobs_step3.sh'])
    # wait for jobs 3
    failed_jobs = wait_and_check_multiple_jobs('dt_components_step3', n_jobs)
    if failed_jobs:
        print("Step 3 failed for the following jobs:")
        print(failed_jobs)
        return

    # submit jobs 4
    subprocess.call(['./jobs_step4.sh'])
    # wait for jobs 4
    failed_jobs = wait_and_check_single_job('dt_components_step4')
    if failed_jobs:
        print("Step 4 failed")
        return

    # submit jobs 5
    subprocess.call(['./jobs_step5.sh'])
    # wait for jobs 5
    failed_jobs = wait_and_check_multiple_jobs('dt_components_step5', n_jobs)
    if failed_jobs:
        print("Step 5 failed for following jobs:")
        print(failed_jobs)
        return

    if have_ws_job:
        # submit jobs 6
        subprocess.call(['./jobs_step6.sh'])
        # wait for jobs 6
        failed_jobs = wait_and_check_multiple_jobs('dt_components_step6', n_jobs)
        if failed_jobs:
            print("Step 6 failed for following jobs:")
            print(failed_jobs)
            return