Python Logger.set方法代码示例

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
    def select_ofdm_params(self):

        parsed = {}
        # parse, calculate mean and avg
        for tup, blk in self.bulk_corr.items():
            fft_length = tup[0]
            cp_length  = tup[1]

            if blk:
                m, e = calculate_avg_std( blk )
                parsed[ tup ] = (m, e, m/e)

        ofdm_tup = None
        max_sum = float("-inf")
        for tup, data in parsed.iteritems():
            if data[0] > max_sum:
                ofdm_tup = tup
                max_sum = data[0]

        if ofdm_tup:
            self.LOGGER[ofdm_tup][1] += 1.0
            Logger.set("correlator", "sel_" + self.LOGGER[ofdm_tup][0], self.LOGGER[ofdm_tup][1])

            self.LOGGER["sel_total"]   += 1.0
            if ofdm_tup == THE_TUPLE:
                self.LOGGER["sel_hit"]   += 1.0
            else:
                self.LOGGER["sel_error"] += 1.0

            Logger.set("correlator", "sel_hit"  , self.LOGGER["sel_hit"])
            Logger.set("correlator", "sel_error", self.LOGGER["sel_error"])
            Logger.set("correlator", "sel_total", self.LOGGER["sel_total"])

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
    def decision(self, data_l, data_m):
        """
        Function called from a signal processing block.
        @param data_l Learner decision regarding channel occupancy.
        @param data_m Manager decision regarding channel occupancy.
        """
        self.strategy.wait()

        self._iteraction += 1

        final_dec = data_l

        if self._valid_feedback:
            final_dec = data_m
            self._time += 19.3
            self._count += 1
            Logger.set('feedback_algorithm', 'total_feedback', self._count)
            Logger.append('feedback_algorithm', 'activation', int(data_m))

            # set feedback in our learning algorithm
            self.learner.feedback = data_m

            # Increase feedback interval if both algorithms are correct
            if data_l == data_m:
                self.strategy.increase_time()
            # else decrease time
            else:
                self.strategy.decrease_time()
        else:
            Logger.append('feedback_algorithm', 'activation', -1)
            self._time += 0.2

        self._valid_feedback = False
        if self.strategy.feedback():
            self._manager.enable(True)
            self._valid_feedback = True

        Logger.append('feedback_algorithm', 'time', self._time)
        Logger.append('feedback_algorithm', 'count', self._count)
        Logger.append('bayes_decision', 'hypothesis', final_dec)

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
    def work(self, input_items, output_items):
        """

        @param input_items
        @param output_items
        """
        for idx in range(len(input_items[0])):
            self._iteraction += 1

            ed_dec = input_items[0][idx][0]
            wf = input_items[1][idx]

            final_dec = ed_dec
            if ed_dec == 0:
                final_dec = 1
                final_dec = self._algorithm.decision(wf)[0]

                Logger.set('feedback_algorithm', 'total_feedback', self._count)

            Logger.append('bayes_decision', 'hypothesis', final_dec)

        return len(input_items[0])

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [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 set [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 set [as 别名]
def cognitive_radio_loop(options, radio, channel_list):
    """
    Program loop here.
    @param options
    @param radio A RadioDevice instance.
    @param channel_list List of Channel objects.
    """

    # Export my server
    command = callback_radio(radio)

    my_rpc = RPCExporter(addr=("143.54.83.30", 8000 + options.my_id))
    my_rpc.register_function('command', command)
    my_rpc.start()

    # Wait broker start
    while not command.run:
        1

    ####
    #Import OTHER RADIOS RPCS
    ####
    rpc_arr = []
    for i in [0, 1, 2, 3]:
            rpc_cli = RPCImporter(addr="http://%s:%d" % (HOSTS_IP[i], 8000 + i))
            rpc_cli.register_function('command')
            rpc_arr.append(rpc_cli)

    # Import PassiveRadio RPC calls
    bs_rpc = RPCImporter(addr="http://%s:9000" % (options.broker_ip))
    bs_rpc.register_function('command')

    # Register parameters for transmission
    Logger.register('radio', ['tx_pkts', 'rx_pkts', 'rx2_pkts', 'channel', 'operation', 'receiver', 'starving',
                              'total_tx', 'total_rx', 'total_starving'])
    # loop
    pkt_len = options.pkt_len
    payload = struct.pack('%sB' % pkt_len, *[options.my_id] * pkt_len)

    print '##### Entering Transmitter loop'
    c_starving = 0

    while command.run:
        """
        ######## FUNCOES:

        ---- BW do canal
        ---- Channel's bandwidth.
        radio.get_bandwidth()

        ---- Num. simbolos na modulacao
        --- Number of symbols in the modulation.
        radio.{tx,rx}.symbols()

        ---- B/S da modulacao
        ---- B/S of the modulation
        radio.{tx,rx}.bits_per_symbol()

        ---- Pkt/s NO ULTIMO SEGUNDO
        ---- Pkt/s in the last second.
        radio.{tx,rx}.counter.get_pkts()

        ---- b/s NO ULTIMO SEGUNDO.
        ---- b/s in the last second.
        radio.{tx,rx}.counter.get_bps()

        ---- Pacotes acumulados desde a ultima chamada.
        ---- Accumulated packages since the last call.
        radio.{tx,rx}.counter.get_pkt_accumulated(clear = False)

        ---- Troca de canal. channel eh um objeto Channel
        ---- Channel changing. channel is a Channel object.
        radio.set_channel(channel)
        #################
        """

        # sense
        while not command.sense and command.run:
            1
        if not command.run:
            break

        sense_data = []

        radio.set_gain(0)
        for channel in channel_list:
            decision, energy = radio.ss.sense_channel(channel, 0.1)
            sense_data.append((decision, float(energy), channel.get_channel()))

        bs_rpc.command([options.my_id, 'sense_data', sense_data])

        # CHOOSE RECEIVER
        #while not command.request_transmission:
        #    1

        # Select a receiver randomly
        #opt  = [0, 1, 2, 3]
        #opt.remove(options.my_id)
        #receiver = random.choice(opt)
        #print '##### DEVICE %d requesting TX to %d' % (options.my_id, receiver)
#.........这里部分代码省略.........

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
def receiver_loop(tb, channel_list, channel, options):
    """
    UP LOOP
    @param tb
    @param channel_list
    @param channel
    @param options
    """

    import xmlrpclib
    from SimpleXMLRPCServer import SimpleXMLRPCServer

    class MyNamespace:
        """

        """
        pass

    g_namespace = MyNamespace()
    g_namespace.tb = tb
    g_namespace.options = options
    g_namespace.server_run = True

    class StoppableXMLRPCServer(SimpleXMLRPCServer):
        """Override of TIME_WAIT"""
        allow_reuse_address = True

        def __init__(self, options):
            SimpleXMLRPCServer.__init__(self, options)
            self.stop = False

        def serve_forever(self):
            while not self.stop:
                self.handle_request()
            print 'exiting server'

        def shutdown(self):
            self.stop = True
            return 0

    server = StoppableXMLRPCServer((options.slave_addr, 8000))
    g_namespace.th = Thread(target=server.serve_forever )

    # Flag que indica quando a execucao deve parar
    # Flag that indicates when the execution must stop.
    g_namespace.run = False
    g_namespace.interferer_channel = 0


    def set_channel(channel):
        """
        RPC for changing the channel.
        @param channel
        """

        print "Received command to handoff to channel  ", channel

        if not g_namespace.options.tx_only:
            g_namespace.tb.tx.center_freq = channel_list[channel]
        g_namespace.tb.rx.center_freq = channel_list[channel]

        g_namespace.interferer_channel = channel
        return 1

    def close_app():
        """
        Closes the app.
        """

        print "Received command to close"
        g_namespace.run = False
        return 1

    def client_started():
        """
        Notifies that the execution has started.
        """
        g_namespace.run = True
        return 1

    Logger.register('receiver', ['channel', 'pkt', 'start_time'])
    Logger.set('receiver', 'start_time', time.time())

    # Registra funcoes no servidor XML e inicia thread do servidor
    # Registers functions in the XML server and starts the server thread.
    server.register_function(set_channel, 'set_channel')
    server.register_function(close_app, 'close_app')
    server.register_function(client_started, 'client_started')

    g_namespace.th.start()
    print "Receiver listening for commands in port 8000"
    print "\t... Waiting for client_started call"

    while g_namespace.run == False:
        1;
    print "\t...client connected"

    global t_rcv, t_cor

    channel = 0
#.........这里部分代码省略.........

# 需要导入模块: from utils import Logger [as 别名]
# 或者: from utils.Logger import set [as 别名]
                    tb, radio, correlator = OpERAUtils.device_definition(options)
                    Logger._enable = True

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

                    try:
                        print "### STARTED"
                        while correlator.enable:
                            print correlator.total_parsed
                            time.sleep(1)
                    except KeyboardInterrupt:
                        pass
                        # Save correlation to a file
                    tfin = time.clock()
                    Logger.set("global", "clock", tfin - tin)

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

                    radio.estimator.dump(options)

                CONVERT_FILES[fad][att] += 1

                with open("parsed_files_lte.log", "w+") as fd:
                    fd.write(yaml.dump(CONVERT_FILES))

                import shutil