Exemplo n.º 1
0
#
unique_id_filter.append('runtime.semi_lagrangian')
jg.runtime.semi_lagrangian_iterations = 2
jg.runtime.semi_lagrangian_convergence_threshold = -1

jg.parallelization.max_wallclock_seconds = max_wallclock_seconds

for tsm in ts_methods[1:]:

    if 'ln_erk' in tsm[0]:
        SetupFDCMethods(jg)
    else:
        SetupSpectralMethods(jg)

    for idx in range(0, timelevels):  #, phys_res in phys_res_list:

        jg.runtime.timestep_size = timestep_sizes[idx]

        jg.runtime.timestepping_method = tsm[0]
        jg.runtime.timestepping_order = tsm[1]
        jg.runtime.timestepping_order2 = tsm[2]
        jg.runtime.space_res_physical = -1
        jg.runtime.space_res_spectral = phys_res_list[idx]
        print("id   dt       Nmodes  ")
        print(idx, jg.runtime.timestep_size, jg.runtime.space_res_physical)

        jg.gen_jobscript_directory()

# Write compile script
jg.write_compilecommands()
Exemplo n.º 2
0
            pspace.num_ranks = 1
            pspace.setup()

            jg.setup_parallelization([pspace, ptime])

            # Use 10 minutes per default to generate plans
            jg.parallelization.max_wallclock_seconds = 60 * 10

            # Set simtime to 0
            #jg.runtime.max_simulation_time = 0

            # No output
            jg.runtime.output_timestep_size = -1
            jg.runtime.output_filename = "-"

            jobdir = 'job_plan_' + jg.getUniqueID()
            jg.gen_jobscript_directory(jobdir)

    # Write compile script
    jg.write_compilecommands("./compile_platform_" + jg.platforms.platform_id +
                             ".sh")

    print("")
    print("Timestepping methods:")
    m = [i[0] for i in ts_methods[1:]]
    m.sort()

    for i in m:
        print(i)
    print("")
Exemplo n.º 3
0
                p.runtime.load_from_dict(tsm[4])

            for pspace_num_cores_per_rank, pspace_num_threads_per_rank, p.runtime.timestep_size in product(
                    params_pspace_num_cores_per_rank,
                    params_pspace_num_threads_per_rank,
                [params_timestep_sizes_explicit[0]]):
                pspace = JobParallelizationDimOptions('space')
                pspace.num_cores_per_rank = pspace_num_cores_per_rank
                pspace.num_threads_per_rank = pspace_num_threads_per_rank
                pspace.num_ranks = 1
                pspace.setup()

                p.setup_parallelization([pspace, ptime])

                # Use 10 minutes per default to generate plans
                p.parallelization.max_wallclock_seconds = 60 * 10

                # Set simtime to 0
                p.runtime.max_simulation_time = 0

                # No output
                p.runtime.output_timestep_size = -1
                p.runtime.output_filename = "-"

                jobdir = 'job_plan_' + p.getUniqueID()
                p.gen_jobscript_directory(jobdir)

    # Write compile script
    p.write_compilecommands("./compile_platform_" + p.platforms.platform_id +
                            ".sh")
            params_timestep_sizes = params_timestep_sizes_explicit_
        elif 'l_irk' in tsm_name or 'lg_irk' in tsm_name:
            params_timestep_sizes = params_timestep_sizes_implicit_
        elif '_sl' in tsm_name:
            params_timestep_sizes = params_timestep_sizes_sl_
        else:
            print("Unable to identify time stepping method " + tsm_name)
            sys.exit(1)

        for (pspace_num_cores_per_rank, pspace_num_threads_per_rank,
             p.runtime.timestep_size) in product(
                 params_pspace_num_cores_per_rank,
                 params_pspace_num_threads_per_rank, params_timestep_sizes):
            pspace = JobParallelizationDimOptions('space')
            pspace.num_cores_per_rank = pspace_num_cores_per_rank
            pspace.num_threads_per_rank = pspace_num_threads_per_rank
            pspace.num_ranks = 1
            pspace.setup()

            p.setup_parallelization([pspace])

            if verbose:
                pspace.print()
                p.parallelization.print()

            p.parallelization.max_wallclock_seconds = estimateWallclockTime(p)

            p.gen_jobscript_directory('job_bench_' + p.getUniqueID())

    p.write_compilecommands()