tsnkit package

Subpackages

• tsnkit.algorithms package
  • Submodules
  • tsnkit.algorithms.at module
    • at
      • at.add_delay_const()
      • at.add_flow_tran_const()
      • at.add_frame_const()
      • at.add_frame_isolation_const()
      • at.add_frame_to_window_range_const()
      • at.add_window_const()
      • at.add_window_order_const()
      • at.add_window_overlap_const()
      • at.get_delay()
      • at.get_gcl()
      • at.get_offset()
      • at.get_queue()
      • at.get_route()
      • at.init()
      • at.output()
      • at.prepare()
      • at.solve()
    • benchmark()
  • tsnkit.algorithms.cg module
    • NodeCG
      • NodeCG.init()
    • benchmark()
    • cg
      • cg.ILP()
      • cg.add_vertex()
      • cg.generator()
      • cg.get_delay()
      • cg.get_gcl()
      • cg.get_offset()
      • cg.get_queue()
      • cg.get_route()
      • cg.init()
      • cg.luby()
      • cg.nods_to_streams()
      • cg.output()
      • cg.prepare()
      • cg.solve()
      • cg.stateful_generator()
      • cg.trigger_completion()
      • cg.trigger_sure()
    • conflict()
    • get_paths()
  • tsnkit.algorithms.cp_wa module
    • benchmark()
    • cp_wa
      • cp_wa.add_delay_const()
      • cp_wa.add_flow_trans_const()
      • cp_wa.add_frame_const()
      • cp_wa.add_frame_isolation_const()
      • cp_wa.add_link_const()
      • cp_wa.get_delay()
      • cp_wa.get_gcl_list()
      • cp_wa.get_offset()
      • cp_wa.get_queue_assignment()
      • cp_wa.get_route()
      • cp_wa.init()
      • cp_wa.output()
      • cp_wa.prepare()
      • cp_wa.solve()
  • tsnkit.algorithms.dt module
    • benchmark()
    • dt
      • dt.collision_free_interval()
      • dt.get_delay()
      • dt.get_gcl()
      • dt.get_offset()
      • dt.get_queue()
      • dt.get_route()
      • dt.init()
      • dt.output()
      • dt.prepare()
      • dt.solve()
    • mod()
  • tsnkit.algorithms.i_ilp module
  • tsnkit.algorithms.i_omt module
    • benchmark()
    • i_omt
      • i_omt.add_delay_const()
      • i_omt.add_flow_isolation_const()
      • i_omt.add_flow_trans_const()
      • i_omt.add_link_const()
      • i_omt.add_obj()
      • i_omt.add_range_constraint()
      • i_omt.add_time_validity_const()
      • i_omt.get_delay()
      • i_omt.get_gcl_list()
      • i_omt.get_offset()
      • i_omt.get_queue_assignment()
      • i_omt.get_route()
      • i_omt.get_weight()
      • i_omt.increase_c_q()
      • i_omt.init()
      • i_omt.init_var()
      • i_omt.output()
      • i_omt.prepare()
      • i_omt.queue_assignment()
      • i_omt.reset_link_var()
      • i_omt.solve()
  • tsnkit.algorithms.jrs_mc module
    • benchmark()
    • jrs_mc
      • jrs_mc.add_delay_const()
      • jrs_mc.add_flow_trans_const()
      • jrs_mc.add_frame_const()
      • jrs_mc.add_link_const()
      • jrs_mc.add_route_const()
      • jrs_mc.get_delay()
      • jrs_mc.get_gcl()
      • jrs_mc.get_offset()
      • jrs_mc.get_queue()
      • jrs_mc.get_route()
      • jrs_mc.get_route_space()
      • jrs_mc.init()
      • jrs_mc.output()
      • jrs_mc.prepare()
      • jrs_mc.set_queue()
      • jrs_mc.solve()
  • tsnkit.algorithms.jrs_nw module
    • benchmark()
    • jrs_nw
      • jrs_nw.add_delay_const()
      • jrs_nw.add_flow_trans_const()
      • jrs_nw.add_frame_const()
      • jrs_nw.add_link_const()
      • jrs_nw.add_route_const()
      • jrs_nw.get_delay()
      • jrs_nw.get_gcl()
      • jrs_nw.get_offset()
      • jrs_nw.get_queue()
      • jrs_nw.get_route()
      • jrs_nw.get_route_space()
      • jrs_nw.init()
      • jrs_nw.output()
      • jrs_nw.prepare()
      • jrs_nw.solve()
  • tsnkit.algorithms.jrs_nw_l module
    • benchmark()
    • jrs_nw_l
      • jrs_nw_l.add_delay_const()
      • jrs_nw_l.add_flow_trans_const()
      • jrs_nw_l.add_frame_const()
      • jrs_nw_l.add_link_const()
      • jrs_nw_l.add_route_const()
      • jrs_nw_l.get_adj_links()
      • jrs_nw_l.get_adj_nodes()
      • jrs_nw_l.get_delay()
      • jrs_nw_l.get_gcl()
      • jrs_nw_l.get_offset()
      • jrs_nw_l.get_queue()
      • jrs_nw_l.get_route()
      • jrs_nw_l.init()
      • jrs_nw_l.output()
      • jrs_nw_l.prepare()
      • jrs_nw_l.solve()
  • tsnkit.algorithms.jrs_wa module
    • benchmark()
    • jrs_wa
      • jrs_wa.add_delay_const()
      • jrs_wa.add_flow_trans_const()
      • jrs_wa.add_frame_const()
      • jrs_wa.add_link_const()
      • jrs_wa.add_link_present_const()
      • jrs_wa.add_routing_const()
      • jrs_wa.get_delay()
      • jrs_wa.get_gcl()
      • jrs_wa.get_offset()
      • jrs_wa.get_queue()
      • jrs_wa.get_route()
      • jrs_wa.get_route_space()
      • jrs_wa.init()
      • jrs_wa.output()
      • jrs_wa.prepare()
      • jrs_wa.set_queue()
      • jrs_wa.solve()
  • tsnkit.algorithms.ls module
    • benchmark()
    • ls
      • ls.find_inject_time()
      • ls.get_delay()
      • ls.get_gcl()
      • ls.get_nw_delay()
      • ls.get_offset()
      • ls.get_queue()
      • ls.get_route()
      • ls.init()
      • ls.match_time()
      • ls.output()
      • ls.prepare()
      • ls.schedule()
      • ls.solve()
  • tsnkit.algorithms.ls_pl module
    • benchmark()
    • collision()
    • get_potential_violate()
    • ls_pl
      • ls_pl.get_delay()
      • ls_pl.get_gcl()
      • ls_pl.get_link_dependency()
      • ls_pl.get_offset()
      • ls_pl.get_queue()
      • ls_pl.get_route()
      • ls_pl.init()
      • ls_pl.output()
      • ls_pl.prepare()
      • ls_pl.solve()
    • merge_dict()
    • order1()
    • order2()
    • schedule_and_update()
    • schedule_link()
    • topology_sort()
  • tsnkit.algorithms.ls_tb module
    • benchmark()
    • ls_tb
      • ls_tb.check()
      • ls_tb.crit()
      • ls_tb.get_bounds()
      • ls_tb.get_delay()
      • ls_tb.get_gcl()
      • ls_tb.get_offset()
      • ls_tb.get_queue()
      • ls_tb.get_route()
      • ls_tb.get_var()
      • ls_tb.init()
      • ls_tb.output()
      • ls_tb.prepare()
      • ls_tb.solve()
  • tsnkit.algorithms.smt_fr module
    • benchmark()
    • smt_fr
      • smt_fr.add_delay_const()
      • smt_fr.add_frame_const()
      • smt_fr.add_link_const()
      • smt_fr.add_seg_const()
      • smt_fr.get_delay()
      • smt_fr.get_delay_perhop()
      • smt_fr.get_gcl_list()
      • smt_fr.get_queue_assignment()
      • smt_fr.get_release_time()
      • smt_fr.get_route()
      • smt_fr.get_size()
      • smt_fr.init()
      • smt_fr.output()
      • smt_fr.prepare()
      • smt_fr.solve()
  • tsnkit.algorithms.smt_nw module
    • benchmark()
    • smt_nw
      • smt_nw.add_delay_const()
      • smt_nw.add_frame_const()
      • smt_nw.add_link_const()
      • smt_nw.get_delay()
      • smt_nw.get_delay_perhop()
      • smt_nw.get_gcl()
      • smt_nw.get_offset()
      • smt_nw.get_queue()
      • smt_nw.get_route()
      • smt_nw.init()
      • smt_nw.output()
      • smt_nw.prepare()
      • smt_nw.solve()
  • tsnkit.algorithms.smt_pr module
    • benchmark()
    • smt_pr
      • smt_pr.add_delay_const()
      • smt_pr.add_flow_trans_const()
      • smt_pr.add_frame_const()
      • smt_pr.add_link_const()
      • smt_pr.add_segments_const()
      • smt_pr.get_delay()
      • smt_pr.get_gcl_list()
      • smt_pr.get_queue_assignment()
      • smt_pr.get_release_time()
      • smt_pr.get_route()
      • smt_pr.init()
      • smt_pr.output()
      • smt_pr.prepare()
      • smt_pr.set_queue_assignment()
      • smt_pr.set_task_var()
      • smt_pr.solve()
  • tsnkit.algorithms.smt_wa module
    • benchmark()
    • smt_wa
      • smt_wa.add_delay_const()
      • smt_wa.add_flow_trans_const()
      • smt_wa.add_frame_const()
      • smt_wa.add_frame_isolation_const()
      • smt_wa.add_link_const()
      • smt_wa.add_queue_range_const()
      • smt_wa.create_task_vars()
      • smt_wa.get_delay()
      • smt_wa.get_gcl_list()
      • smt_wa.get_queue_assignment()
      • smt_wa.get_release_time()
      • smt_wa.get_route()
      • smt_wa.init()
      • smt_wa.output()
      • smt_wa.prepare()
      • smt_wa.solve()
  • Module contents
    • _Method
      • _Method._abc_impl
      • _Method.init()
      • _Method.output()
      • _Method.prepare()
      • _Method.solve()
    • benchmark()
• tsnkit.simulation package
  • Submodules
  • tsnkit.simulation.tas module
    • ConfigTypes
      • ConfigTypes.GCL
      • ConfigTypes.OFFSET
      • ConfigTypes.QUEUE
      • ConfigTypes.ROUTE
    • match_config_type()
    • match_time()
    • simulation()
  • Module contents
• tsnkit.core package
  • Submodules
  • tsnkit.core._calculate module
  • tsnkit.core._common module
    • _interface()
    • benchmark()
    • flatten()
    • parse_command_line_args()
    • parse_command_line_constants()
  • tsnkit.core._config module
    • Config
      • Config.to_csv()
    • Delay
      • Delay.format_delay_type()
      • Delay.is_valid_delay_format()
      • Delay.to_csv()
    • GCL
      • GCL.format_gcl_type()
      • GCL.is_overlap()
      • GCL.is_small_entry()
      • GCL.is_valid_gcl_format()
      • GCL.to_csv()
    • Queue
      • Queue.format_queue_type()
      • Queue.is_valid_queue_format()
      • Queue.is_valid_queue_range()
      • Queue.to_csv()
    • Release
      • Release.format_release_type()
      • Release.is_valid_release_format()
      • Release.to_csv()
    • Route
      • Route.format_route_type()
      • Route.is_valid_route_format()
      • Route.is_valid_route_logic()
      • Route.to_csv()
    • Size
      • Size.to_csv()
    • result_slot_to_ns()
  • tsnkit.core._constants module
  • tsnkit.core._io module
    • Result
      • Result.error
      • Result.schedulable
      • Result.unknown
      • Result.unschedulable
    • Statistics
      • Statistics.content()
      • Statistics.header()
      • Statistics.output_format
      • Statistics.to_list()
      • Statistics.update()
    • check_time_limit()
    • get_caller_name()
  • tsnkit.core._network module
    • Link
      • Link.dst
      • Link.name
      • Link.q_num
      • Link.rate
      • Link.src
      • Link.t_proc
      • Link.t_prop
      • Link.t_sync
    • Network
      • Network.add_link()
      • Network.del_link()
      • Network.e_nodes
      • Network.get_all_path()
      • Network.get_income_links()
      • Network.get_income_nodes()
      • Network.get_link()
      • Network.get_link_pairs()
      • Network.get_links()
      • Network.get_node()
      • Network.get_nodes()
      • Network.get_nodes_es()
      • Network.get_nodes_sw()
      • Network.get_outcome_links()
      • Network.get_outcome_nodes()
      • Network.get_shortest_path()
      • Network.links
      • Network.max_t_proc
      • Network.net_np
      • Network.net_nx
      • Network.nodes
      • Network.num_l
      • Network.num_n
      • Network.s_nodes
      • Network.update_link()
    • Node
      • Node.num_port
      • Node.sync_error
      • Node.type
    • NodeType
      • NodeType.es
      • NodeType.sw
    • Path
      • Path.get_in_link()
      • Path.get_len_link()
      • Path.get_len_node()
      • Path.get_link()
      • Path.get_next_link()
      • Path.get_next_node()
      • Path.get_out_link()
      • Path.get_prev_link()
      • Path.get_prev_node()
      • Path.iter_link()
      • Path.iter_node()
      • Path.link_path_to_node_path()
      • Path.links
      • Path.llen
      • Path.nlen
      • Path.node_path_to_link_path()
      • Path.nodes
      • Path.sort_links()
    • check_network_format()
    • load_network()
  • tsnkit.core._stream module
    • Stream
      • Stream.deadline
      • Stream.dst
      • Stream.dst_mul
      • Stream.first_link
      • Stream.get_frame_indexes()
      • Stream.get_link()
      • Stream.get_next_link()
      • Stream.get_next_node()
      • Stream.get_num_frames()
      • Stream.get_prev_link()
      • Stream.get_prev_node()
      • Stream.get_t_trans()
      • Stream.is_in_path()
      • Stream.jitter
      • Stream.last_link
      • Stream.links
      • Stream.period
      • Stream.routing_path
      • Stream.size
      • Stream.src
      • Stream.t_trans
      • Stream.t_trans_1g
    • StreamSet
      • StreamSet.get_frame_index_pairs()
      • StreamSet.get_merged_links()
      • StreamSet.get_next_link()
      • StreamSet.get_next_node()
      • StreamSet.get_pairs()
      • StreamSet.get_pairs_on_link()
      • StreamSet.get_prev_link()
      • StreamSet.get_prev_node()
      • StreamSet.get_shared_links()
      • StreamSet.get_stream()
      • StreamSet.get_streams()
      • StreamSet.get_streams_on_link()
      • StreamSet.get_t_trans()
      • StreamSet.is_route_valid()
      • StreamSet.lcm
      • StreamSet.length
      • StreamSet.num_frames
      • StreamSet.set_routing()
      • StreamSet.set_routings()
      • StreamSet.streams
    • check_stream_format()
    • load_stream()
  • tsnkit.core._system module
    • find_files_with_prefix()
    • init_output_folder()
    • is_timeout()
    • kill_if()
    • kill_process()
    • mem_log()
    • oom_manager()
    • time_log()
  • Module contents

Module contents

tsnkit.

A simple scheduling toolkit for time-sensitive network in Python.