Python Logger.dump方法代码示例

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
                print "******************************************\n"
                os._exit(1)

        # Operation is "set a new frequency".
        elif reply is OPT_SET_FREQ:
            # gets the frequency
            freq, no_freq = menu.get_value_in_range(MIN_FREQ, MAX_FREQ, QUESTION_SET_FREQ, STR_FREQ)
            if no_freq is False:
                radio.set_center_freq(freq)
                # prints the energy
                OpERAUtils.printing_energy()


        # Operation is "set the gain multiplier".
        elif reply is OPT_SET_GAIN:
            # gets the gain
            gain, no_gain = menu.get_value_in_range(MIN_GAIN, MAX_GAIN, QUESTION_SET_GAIN, STR_GAIN)
            if no_gain is False:
                radio.set_gain(gain)
                OpERAUtils.printing_energy()


if __name__ == "__main__":
    tb, radio = OpERAUtils.device_definition()

    try:
        main(tb, radio)
    except KeyboardInterrupt:
        tb.stop()
        Logger.dump('./dump/', '', 0)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]

if __name__ == "__main__":
    parser = OptionParser()
    parser.add_option("", "--test-duration", type="int", default=600,
                      help="Test Duration.")
    parser.add_option("", "--iteration", type="int", default=0,
                      help="Iteration")
    parser.add_option("", "--sending-duration", type="int", default=5,
                      help="Sending duration during each transmittion.")

    (options, args) = parser.parse_args()

    globs.options = options

    Logger._enable = True
    Logger.register('bs', ['channel_count', 'links', 'it_dur', 'total_iterations', 'interference_count',
                           'interference_time', 'interference_hit_count', 'interference_hit_time', 'decision_time',
                           'tx_and_rx_pkts'])
    main(options)

    Logger.set('bs', 'channel_count', globs.p_channels_count)
    Logger.set('bs', 'total_iterations', globs.p_total_iterations)
    Logger.set('bs', 'interference_count', globs.p_channels_interference_count)
    Logger.set('bs', 'interference_time', globs.p_channels_interference_time)
    Logger.set('bs', 'interference_hit_count', globs.p_channels_interference_hit_count)
    Logger.set('bs', 'interference_hit_time', globs.p_channels_interference_hit_time)

    Logger.dump('./results/', 'bs_burst_' + str(options.sending_duration) + '_it_' + str(options.iteration))
    os._exit(1)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
                      help="Length of packet to be send.")
    parser.add_option("", "--port", type="int", default=8000,
                      help="Port for RPC calls.")
    parser.add_option("", "--sending-duration", type="int", default=5,
                      help="Sending duration during each transmission.")
    parser.add_option("", "--sensing-duration", type="eng_float", default=0.1,
                      help="Sensing duration during each sensing.")
    parser.add_option("", "--my-id", type="int", help="USRP ID.")
    parser.add_option("", "--algo-name", type="string", default=None,
                      help="Algorithm name.")
    parser.add_option("", "--iteration", type="int", default=0,
                      help="Iteration")
    parser.add_option("", "--broker-ip", type="string", default="143.54.83.30",
                      help="Broker IP")

    (options, args) = parser.parse_args()

    if not options.algo_name:
        raise AttributeError("--algo-name must be provided")

    Logger._enable = True

    main(options)

    device = "radio_" + str(options.my_id)
    Logger.dump('./results_{algo}/'.format(algo=options.algo_name),
                device + '_it_' + str(options.iteration) + '_pkt_' + str(options.pkt_len) + '_burst_' +
                '%2.1f' % options.sending_duration + '_ssdur_' + '%2.1f' % options.sensing_duration)

    os._exit(1)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
    THE_TUPLE =  (options.fft_length, options.cp_length)
    MAX_PARSED_SAMPLES = options.max_parsed

    import yaml
    noise = yaml.load(open("noise.txt", "r"))
    options.threshold = noise[options.ebn0][0.9]

    Logger._enable = True
    print "#### TESTING WITH EBN0 %f, IT %d" % (options.ebn0, options.it)

    tin = time.clock()
    tb.start()


    parse_file(options)

    #Save correlation to a file
    tfin = time.clock()
    Logger.set('global', 'clock', tfin - tin)

    Logger._enable = False
    tb.stop()
    tb.wait()
    print "### STOPPED"

    d =  "from_file/ebn0_%d/" % options.ebn0
    sd =  "%d_%d" % (options.fft_length, options.cp_length)
    Logger.dump(d, sd, options.it)
    radio.estimator.dump(options)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
    parser.add_option("", "--platform", type="string", default="mac",
                      help="Machine running the test.")
    parser.add_option("", "--iteration", type="int", default=-1,
                      help="Test Iteration.")
    parser.add_option("", "--sending-duration", type="float", default=1.0,
                      help="TX duration between sensing.")
    parser.add_option("", "--sensing-duration", type="float", default=0.1,
                      help="SS duration between transmission.")

    (options, args) = parser.parse_args()

    options.tx_only = options.mode == 'txonly'

    print '#######################################'
    print '# mode: ' + str(options.mode)
    print '# ss  : ' + str(options.sensing_duration)
    print '# sd  : ' + str(options.sending_duration)
    print '#######################################'

    if options.log:
        Logger._enable = True
    Logger._enable = True
    main(options)

    # save log
    dev = './receiver' if options.interferer else './transmitter'
    Logger.dump('./{os}_results'.format(os=options.platform),
            '/' + dev + '_' + options.platform + '_dur_' + str(int(options.duration)) + '_pkt_' + str(options.pkt_size)
            + '_burst_' + '%2.1f' % options.sending_duration + '_ssdur_' + '%2.1f' % options.sensing_duration +
            ('_mode_txonly' if options.tx_only else '_mode_ss'), options.iteration)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
    decision_func = {
        'simple': algo_simple,
        'fuzzy': algo_fuzzy,
        'graph': algo_graph,
        'genetic': algo_genetic,
        'sim_annealing': algo_sim_annealing,
        'blp': algo_blp
    }

    globs.decision_func = decision_func[options.algo_name]
    globs.options = options

    Logger._enable = True
    Logger.register('bs',
                    ['channel_count', 'links', 'it_dur', 'total_iterations', 'interference_count', 'interference_time',
                     'interference_hit_count', 'interference_hit_time', 'decision_time', 'tx_and_rx_pkts'])
    main(options)

    Logger.set('bs', 'channel_count', globs.p_channels_count)
    Logger.set('bs', 'total_iterations', globs.p_total_iterations)
    Logger.set('bs', 'interference_count', globs.p_channels_interference_count)
    Logger.set('bs', 'interference_time', globs.p_channels_interference_time)
    Logger.set('bs', 'interference_hit_count', globs.p_channels_interference_hit_count)
    Logger.set('bs', 'interference_hit_time', globs.p_channels_interference_hit_time)
    Logger.set('bs', 'tx_and_rx_pkts', globs.tx_pkts)

    Logger.dump('./results_{algo}/'.format(algo=options.algo_name),
                'bs_burst_' + str(options.sending_duration) + '_it_' + str(options.iteration))

    os._exit(1)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
                tb.stop()
                continue_loop = False
                print "\n******************************************"
                print "\tQuitting the program."
                print "******************************************\n"
                os._exit(1)

        # Operation is "set a new frequency".
        elif reply is OPT_SET_TX_FREQ:
            # gets the frequency
            freq, no_freq = menu.get_value_in_range(MIN_FREQ, MAX_FREQ, QUESTION_SET_TX_FREQ, STR_FREQ)
            if no_freq is False:
                radio.center_freq = freq

        # Operation is "set the gain multiplier".
        elif reply is OPT_SET_GAIN:
            # gets the gain
            gain, no_gain = menu.get_value_in_range(MIN_GAIN, MAX_GAIN, QUESTION_SET_GAIN, STR_GAIN)
            if no_gain is False:
                radio._set_gain(gain)


if __name__ == "__main__":
    tb, radio = OpERAUtils.device_definition()

    try:
        main(tb, radio)
    except KeyboardInterrupt:
        tb.stop()
        Logger.dump("./dump/", "", 0)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
if __name__ == "__main__":

    parser = OptionParser(option_class=eng_option)
    parser.add_option("", "--pkt-len", type="int", default=64,
                      help="Length of packet to be send.")
    parser.add_option("", "--port", type="int", default=8000,
                      help="Port for RPC calls.")
    parser.add_option("", "--sending-duration", type="int", default=5,
                      help="Sending duration during each transmission.")
    parser.add_option("", "--sensing-duration", type="eng_float", default=0.1,
                      help="Sensing duration during each sensing.")
    parser.add_option("", "--my-id", type="int", help="USRP ID.")
    parser.add_option("", "--iteration", type="int", default=0,
                      help="Iteration")
    parser.add_option("", "--broker-ip", type="string", default="143.54.83.30",
                      help="Broker IP")

    (options, args) = parser.parse_args()

    Logger._enable = True

    main(options)

    device = "radio_" + str(options.my_id)
    Logger.dump('./results/',
                device + '_it_' + str(options.iteration) + '_pkt_' + str(options.pkt_len) + '_burst_' +
                '%2.1f' % options.sending_duration + '_ssdur_' + '%2.1f' % options.sensing_duration)

    os._exit(1)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
for config in config_manager.job_group_configs:
	build_service = BuildResultsService(config, logger)
	group_results = []

	reporting_status = ReportingStatus(0, len(config.job_application_mappings))
	progress_bar = ProgressBar(reporting_status, config.view_name)
	progress_bar.start()
	try:
		for app_title in config.job_application_mappings:
			job_config = config.config_for(app_title)
			build_service = BuildResultsService(job_config, logger)
			results = build_service.compose_single_job_regression_results(app_title)
			group_results.append(results)
			reporting_status.current_build_number += 1
		reporting_status.current_build_number += 1
		progress_bar.join()
		overall_result = compose_overall_result(config, group_results)
		overall_results.append(overall_result)

		sorted_results = sorted(group_results, key=lambda k: k['app_title'])
		excel_manager.write_results_to_worksheet(group_results, config.sheet_title, is_rerun)
	except:
		progress_bar.stop_execution()
		raise
	is_rerun = True

excel_manager.write_results_to_worksheet(overall_results, 'Regression Results', True, table_name='Module',
	table_title='Overall Automated Regression Results', is_failures_reported=False, is_main_sheet=True)
excel_manager.save_workbook()
logger.dump()

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
                        radio.sensing._component.set_center_freq(1)
                        print "--- Setting ch_status to 1"
                        Logger._ch_status = 1
                    else:
                        radio.sensing._component.set_center_freq(0)
                        print "--- Setting ch_status to 0"
                        Logger._ch_status = 0

                    if t_tot == 0:
                        tb.start()
                    time.sleep(t_next)

                    t_tot += t_next
                    if t_tot >= 10.0:
                        break
                ################################################################################
                tfin = time.clock()
                tb.stop()
                tb.wait()
                enable = False

                Logger.register("global", ["clock"])
                Logger.set("global", "clock", tfin - tin)

                _sdir = "/%s_%02d_%02d/" % (options.sensing, options.ph1 * 10, pfa)
                _dir = "single/ebn0_{ebn0}".format(ebn0=ebn0)
                Logger.dump(_dir, _sdir, options.it)
                Logger.clear_all()
                with open("log.txt", "a+") as log:
                    log.write(_dir + _sdir)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import dump [as 别名]
def execute_sensing_decision(hit_rate, num_steps):
    """
    Execution of the sensing_decision module.
    @param hit_rate A list with the hit ratio for every cpe. Example: hit_rate = [90, 78, 32] - the first cpe has a
    hit ratio of 90%, the second has a hit ratio of 78% and the third has a hit ratio of 32%.
    @param num_steps Number of executions of the sensing_result
    """

    feedback_control = 5
    increase_rate = 0.1
    decrease_rate = 0.1
    num_cpes = len(hit_rate)

    list_str_cpes = []

    for i in range(num_cpes):
        list_str_cpes.append("cpe" + str(i+1))

    # save strings in the Logger
    Logger._enable = True
    Logger.register("reward", list_str_cpes)

    sdc = SDController(num_cpes, feedback_control, increase_rate, decrease_rate)    

    # each element of this array is also an array. the array of the index 0 (ie, array_hit[0]) corresponds to the hit_
    # rate[0] and so on.
    cpe_array = [0] * num_steps
    
    array_hit = []

    # num_cpes is the length of array_hit
    for i in range(num_cpes):
        # need to append as a list because otherwise if we modify some subarray, ALL arrays are modified too.
        array_hit.append(list(cpe_array))

    # list of lists, where the random indexes will be.
    list_indexes = []
    for i in range(num_cpes):
        list_indexes.append(list([]))

    # set some random positions of the arrays to one.
    for i in range(num_cpes):
        while len(list_indexes[i]) < (num_steps - (num_steps * hit_rate[i]/100)):
            rand = random.randint(0, num_steps-1)
            if rand not in list_indexes[i]:
                list_indexes[i].append(rand)
                array_hit[i][rand] = 1

    for step in range(num_steps):
        sensing_result = []
            
        for cpe in range(num_cpes):
            sensing_result.append(array_hit[cpe][step])
            Logger.append("reward", list_str_cpes[cpe], sdc._reward[cpe])    
    

        sdc.sensing_decision(sensing_result, num_cpes)    

    Logger.dump('./dump', '/cpes', 0)

    print "\n\n REWARD\n\n"
    for cpe in range(num_cpes):
        print "reward cpe %i: " %(cpe+1) + str(sdc._reward[cpe])

    print "TOTAL HIT RATE: ", float(sdc._total_idle/float(num_steps))