2018-09-26 09:06:51 weixin_42233629 阅读数 622

python中的dis模块可以查看一句python代码的cpu运行轨迹,也就是cpu指令,
如果只是读取数据时,如读取一个函数,此时数据是安全的,因为没有涉及任何修改,
当改数据时,可能会涉及数据不安全,如多个线程同时修改一个数据,原因是一句代码对应了多条cpu指令,如有4条指令,当执行完第二条时,cpu时间片轮转了,此时数据可能发生错误。
所以任何 += -= *- 都是数据不安全的

  • 没有存进去,只有load读数据,安全
import dis
def func2():
    a = 0
    a + 1
dis.dis(func2)

运行结果

  3           0 LOAD_CONST               1 (0)
              2 STORE_FAST               0 (a)

  4           4 LOAD_FAST                0 (a)
              6 LOAD_CONST               2 (1)
              8 BINARY_ADD
             10 POP_TOP
             12 LOAD_CONST               0 (None)
             14 RETURN_VALUE
  • 数据存进去,数据不安全
import dis
def func2():
    a = 0
    a += 1
dis.dis(func2)

运行结果

  3           0 LOAD_CONST               1 (0)
              2 STORE_FAST               0 (a)   

  4           4 LOAD_CONST               2 (1)
              6 STORE_FAST               0 (a)
              8 LOAD_CONST               0 (None)
             10 RETURN_VALUE
以上涉及cpu多步指令

在这里插入图片描述

2018-02-04 12:36:07 NightCharm 阅读数 507

dis模块 入门

Python代码先翻译成字节码,又由Python虚拟机来执行字节码,python的字节码类似汇编指令的中间语言,一个Python语言会对用若干字节码指令,虚拟机一条条执行指令,从而完成程序的执行

Python dis 模块支持对Python代码进行反汇编, 生成字节码指令。

import dis
def main():
    while 1:
        pass
    while True:
        pass
dis.dis(main)

执行结果如下

  3           0 SETUP_LOOP               4 (to 6)

  4     >>    2 JUMP_ABSOLUTE            2
              4 POP_BLOCK

  5     >>    6 SETUP_LOOP               4 (to 12)

  6     >>    8 JUMP_ABSOLUTE            8
             10 POP_BLOCK
        >>   12 LOAD_CONST               0 (None)
             14 RETURN_VALUE

以第一条指令为例, 第一列的数字(2)表示对应源代码的行数。第二列的数字是字节码的索引,指令LOAD_CONST在0位置。第三列是指令本身对应的人类可读的名字。第四列表示指令的参数。第5列则是计算后的实际参数。其中的“>>” 表示跳转的目标, (to x) 表明了跳转到索引为x的指令。

具体的指令参数可以参考https://docs.python.org/3/library/dis.html

至于为什么使用上述例子:

因为我最开始就听到过一句话就是: while 1 的执行速度比 while True 的执行速度快,当然 这句话在python2中是正确的,但是在python3中可以看出 没有区别。在python 3 中都是在执行到while 的时候直接跳转了

在python2中 True 并不是一个关键字,而是一个内置参数,我们在python2中可以输入

>>> True + True
2

在python2中 While True 代表着需要进行一步的运算 将True转换成1 在进行判断,所以 while 1 的执行速度比while True快

如果不信的话看下面例子

>>> import dis
>>> def main():
...     while 1:
...             pass
...     while True:
...             pass
...
>>> dis.dis(main)
  2           0 SETUP_LOOP               4 (to 7)

  3     >>    3 JUMP_ABSOLUTE            3
              6 POP_BLOCK

  4     >>    7 SETUP_LOOP              10 (to 20)
        >>   10 LOAD_GLOBAL              0 (True)
             13 POP_JUMP_IF_FALSE       19

  5          16 JUMP_ABSOLUTE           10
        >>   19 POP_BLOCK
        >>   20 LOAD_CONST               0 (None)
             23 RETURN_VALUE

看不懂具体是什么意思但是可以看得出 在Python2 中 while True 多了 两 条指令

2013-08-18 14:20:57 u011279649 阅读数 1521
crash> help dis

NAME
  dis - disassemble

SYNOPSIS
  dis [-rludx][-b [num]] [address | symbol | (expression)] [count]

DESCRIPTION
  This command disassembles source code instructions starting (or ending) at
  a text address that may be expressed by value, symbol or expression:
/*-r:reverse
 *-l:displays source code line number data
 **/

            -r  (reverse) displays all instructions from the start of the
                routine up to and including the designated address.
            -l  displays source code line number data in addition to the
                disassembly output.
            -u  address is a user virtual address in the current context;
                otherwise the address is assumed to be a kernel virtual address.
                If this option is used, then -r and -l are ignored.
/*-x/d:output format
 **/

            -x  override default output format with hexadecimal format.
            -d  override default output format with decimal format.
      -b [num]  modify the pre-calculated number of encoded bytes to skip after
                a kernel BUG ("ud2a") instruction; with no argument, displays
                the current number of bytes being skipped. (x86 and x86_64 only)
/*从那个位置开始 dis-assember:
 *address, symbol and expression.
 **/

       address  starting hexadecimal text address.
        symbol  symbol of starting text address.  On ppc64, the symbol
                preceded by '.' is used.
  (expression)  expression evaluating to a starting text address.

/*count: the number of instructions to be disassembled (default is 1)*/
         count  the number of instructions to be disassembled (default is 1).
                If no count argument is entered, and the starting address
                is entered as a text symbol, then the whole routine will be
                disassembled.  The count argument is ignored when used with
                the -r option.

EXAMPLES
  Disassemble the sys_signal() routine without, and then with, line numbers:

crash> dis run_init_process
    0xc000863c <run_init_process>:  mov     r12, sp
    0xc0008640 <run_init_process+4>:        push    {r11, r12, lr, pc}
    0xc0008644 <run_init_process+8>:        sub     r11, r12, #4
    0xc0008648 <run_init_process+12>:       ldr     r1, [pc, #12]   ; 0xc000865c <run_init_process+32>
    0xc000864c <run_init_process+16>:       mov     r2, r1
    0xc0008650 <run_init_process+20>:       str     r0, [r2], #136  ; 0x88
    0xc0008654 <run_init_process+24>:       bl      0xc0011a40 <kernel_execve>
    0xc0008658 <run_init_process+28>:       ldm     sp, {r11, sp, pc}

 

crash> dis -l run_init_process

    /home/wenshuai/code/3.4kernel/linux_kernel/init/main.c: 793
    0xc000863c <run_init_process>:  mov     r12, sp
    0xc0008640 <run_init_process+4>:        push    {r11, r12, lr, pc}
    0xc0008644 <run_init_process+8>:        sub     r11, r12, #4
    /home/wenshuai/code/3.4kernel/linux_kernel/init/main.c: 794
    0xc0008648 <run_init_process+12>:       ldr     r1, [pc, #12]   ; 0xc000865c <run_init_process+32>
    0xc000864c <run_init_process+16>:       mov     r2, r1
    0xc0008650 <run_init_process+20>:       str     r0, [r2], #136  ; 0x88
    /home/wenshuai/code/3.4kernel/linux_kernel/init/main.c: 795
    0xc0008654 <run_init_process+24>:       bl      0xc0011a40 <kernel_execve>
    /home/wenshuai/code/3.4kernel/linux_kernel/init/main.c: 796
    0xc0008658 <run_init_process+28>:       ldm     sp, {r11, sp, pc}
 
  Given a return address expression of "run_init_process+16", find out the
  function that run_init_process calls by using the reverse flag:

crash> dis -r (run_init_process+16)

0xc000863c <run_init_process>:  mov     r12, sp
0xc0008640 <run_init_process+4>:        push    {r11, r12, lr, pc}
0xc0008644 <run_init_process+8>:        sub     r11, r12, #4
0xc0008648 <run_init_process+12>:       ldr     r1, [pc, #12]   ; 0xc000865c <run_init_process+32>
0xc000864c <run_init_process+16>:       mov     r2, r1

    
  Disassemble 10 instructions starting at user virtual address 0x81ec624:

    crash> dis -u 81ec624 10
    0x81ec624:      push   %ebp
    0x81ec625:      mov    %esp,%ebp
    0x81ec627:      sub    $0x18,%esp
    0x81ec62a:      movl   $0x1,0x8(%ebp)
    0x81ec631:      mov    0x82f9040,%eax
    0x81ec636:      mov    0x10(%eax),%edx
    0x81ec639:      and    $0x100,%edx
    0x81ec63f:      mov    0x14(%eax),%ecx
    0x81ec642:      and    $0x0,%ecx
    0x81ec645:      mov    %ecx,%eax
 
  Override the current decimal output radix format:

    crash> dis sys_read 10 -x
    0xffffffff8001178f <sys_read>:  push   %r13
    0xffffffff80011791 <sys_read+0x2>:      mov    %rsi,%r13
    0xffffffff80011794 <sys_read+0x5>:      push   %r12
    0xffffffff80011796 <sys_read+0x7>:      mov    $0xfffffffffffffff7,%r12
    0xffffffff8001179d <sys_read+0xe>:      push   %rbp
    0xffffffff8001179e <sys_read+0xf>:      mov    %rdx,%rbp
    0xffffffff800117a1 <sys_read+0x12>:     push   %rbx
    0xffffffff800117a2 <sys_read+0x13>:     sub    $0x18,%rsp
    0xffffffff800117a6 <sys_read+0x17>:     lea    0x14(%rsp),%rsi
    0xffffffff800117ab <sys_read+0x1c>:     callq  0xffffffff8000b5b4 <fget_light>

crash>
2016-06-14 02:49:35 qs9816 阅读数 4517

Python 代码先被编译为字节码后,再由Python虚拟机来执行字节码, Python的字节码是一种类似汇编指令的中间语言, 一个Python语句会对应若干字节码指令,虚拟机一条一条执行字节码指令, 从而完成程序执行。
Python dis 模块支持对Python代码进行反汇编, 生成字节码指令。
先来一小段代码:

In[6]: def test():
...         x = 1
...         if x < 3:
...             return "yes"
...         else:
...             return "no"
代码执行后会输出:

In[7]: import dis
In[8]: dis.dis(test)
  2           0 LOAD_CONST               1 (1)
              3 STORE_FAST               0 (x)

  3           6 LOAD_FAST                0 (x)
              9 LOAD_CONST               2 (3)
             12 COMPARE_OP               0 (<)
             15 POP_JUMP_IF_FALSE       22

  4          18 LOAD_CONST               3 ('yes')
             21 RETURN_VALUE        

  6     >>   22 LOAD_CONST               4 ('no')
             25 RETURN_VALUE        
             26 LOAD_CONST               0 (None)
             29 RETURN_VALUE        


以第一条指令为例, 第一列的数字(2)表示对应源代码的行数。第二列的数字是字节码的索引,指令LOAD_CONST在0位置。第三列是指令本身对应的人类可读的名字。第四列表示指令的参数。第5列则是计算后的实际参数。其中的“>>" 表示跳转的目标, 第4列的“22” 表明了跳转到索引为22的指令。




Python代码在编译过程中会生成CodeObject, CodeObject是在虚拟机中的抽象表示, 在Python C源码中表示为PyCodeObject, 而生成的.pyc 文件则是字节码在磁盘中的表现形式。

以Python代码为讲,test.__code__.co_code 表示test函数的字节码指令序列。
将此序列打印出来,

code = [ord(i) for i in list(test.__code__.co_code)]
print code
输出:

[100, 1, 0, 125, 0, 0, 124, 0, 0, 100, 2, 0, 107, 0, 0, 114, 22, 0, 100, 3, 0, 83, 100, 4, 0, 83, 100, 0, 0, 83]


对照dis输出的字节码指令, 以[100,1,0]序列为例。100表示在Python字节码定义中的索引,在python代码中,
 可以通过dis.opname[100]查看,即为LOAD_CONST。而后的两个字节表示指令的参数。而dis输出的字节码指令中,
第二列的字节码索引则是指当前指令在co_code序列中所在的位置。
dis输出的字节码指令中,部分指令是没有参数, 在co_code 中也同样可以看到,83(RETURN_VALUE)直接接上下一条指令100(LOAD_CONST)。















2016-04-17 15:39:45 u014734740 阅读数 637

swift语言实现异步网络post请求,用NSDictionary封装post表单。

class func post(urlString urlString: String?,postParams: NSDictionary!,completion: (data: NSString?) -> Void){
        if urlString == nil {
            dispatch_async(dispatch_get_main_queue(), { () -> Void in
                print("urlString 为空")
                completion(data: nil)
            })
        }
        
        let url = NSURL(string: urlString!)//post的url地址
        let request = NSMutableURLRequest(URL: url!, cachePolicy: NSURLRequestCachePolicy.UseProtocolCachePolicy, timeoutInterval: 10)
        request.HTTPMethod = "POST"
        parseParams(Params: postParams, completion: {(result) in
            let postData: NSData = (result?.dataUsingEncoding(NSUTF8StringEncoding))!
            request.HTTPBody = postData//post表单
        })
        let queue = NSOperationQueue()
        NSURLConnection.sendAsynchronousRequest(request, queue: queue, completionHandler: {
            (response,data,error) -> Void in
            let httpResponse = response as? NSHTTPURLResponse
            if httpResponse?.statusCode == 200{
                let parseData = NSString(data: data!, encoding: NSUTF8StringEncoding)//self.parseJSONData(data)
                dispatch_async(dispatch_get_main_queue(),{
                    () -> Void in
                    completion(data: parseData)
                })
            }else {
                dispatch_async(dispatch_get_main_queue(), {
                    () -> Void in
                    print(error)
                    completion(data: nil)
                })
            }
        })
    }
当然在post之前还要将传过来的NSDictionary转化为post的固定格式

class func parseParams(Params Params: NSDictionary!,completion: (paramString: NSString?) -> Void){
        var keyValueFormat: String?
        let result = NSMutableString()
        let keyEnum = Params.keyEnumerator()
        while let key = keyEnum.nextObject() as? String{
            keyValueFormat = String.init(format: "%@=%@&", arguments: [key,(Params.valueForKey(key)?.description)!])//post的键值对
            result.appendString(keyValueFormat!)
        }
        completion(paramString: result)
    }


DIS 光流详解

阅读数 929

没有更多推荐了,返回首页