精华内容
下载资源
问答
  • linux代码段,数据段,BSS段, 堆,栈

    千次阅读 2013-10-22 14:42:10
    linux代码段,数据段,BSS段, 堆,栈 网上摘抄了一些,自己组织好了,以便参考 !!!!  进 程(执行的程序)会占用一定数量的内存,它或是用来存放从磁盘载入的程序代码,或是存放取自用户输入的数据等等。不过进程...

     

     linux代码段,数据段,BSS段, 堆,栈


    网上摘抄了一些,自己组织好了,以便参考 !!!! 


    进 程(执行的程序)会占用一定数量的内存,它或是用来存放从磁盘载入的程序代码,或是存放取自用户输入的数据等等。不过进程对这些内存的管理方式因内存用途不一而不尽相同,有些内存是事先静态分配和统一回收的,而有些却是按需要动态分配和回收的。对任何一个普通进程来讲,它都会涉及到5种不同的数据段(如代码段,数据段,BSS段,堆段,栈段)。在进程被载入内存中时,基本上被分裂成主要的6个小的节(section)---如, .text节, .data节, .bss节, 堆节, 栈节, 环境/参数节.

     

     

    一、Linux进程的五个段

    下面我们来简单归纳一下进程对应的内存空间中所包含的5种不同的数据区都是干什么的。

     

    重点:

    代码段、数据段、堆栈段,这是一个概念
    堆、栈、全局区、常量区,这是另一个概念

     

     

    1)代码段:代码段是用来存放可执行文件的操作指令,也就是说是它是可执行程序在内存中的镜像。代码段需要防止在运行时被非法修改,所以只准许读取操作,而不允许写入(修改)操作——它是不可写的代码段(code segment/text segment)通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定,并且内存区域通常属于只读, 某些架构也允许代码段为可写,即允许修改程序。在代码段中,也有可能包含一些只读的常数变量,例如字符串常量等。

     

    2)数据段:数据段用来存放可执行文件中已初始化全局变量,换句话说就是存放程序静态分配的变量和全局变量。

     

    3BSS段:BSS段包含了程序中未初始化的全局变量,在内存中 bss段全部置零。BSS段(bss segment)通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。

     

    4)堆(heap):堆是用于存放进程运行中被动态分配的内存段,它的大小并不固定,可动态扩张或缩减。当进程调用malloc等函数分配内存时,新分配的内存就被动态添加到堆上(堆被扩张);当利用free等函数释放内存时,被释放的内存从堆中被剔除(堆被缩减)

    它的物理内存空间是由程序申请的,并由程序负责释放。

     

    5)栈:栈又称堆栈,栈是用户存放程序临时创建的局部变量,也就是说我们函数括弧“{}中定义的变量(但不包括static声明的变量,static意味着在数据段中存放变量)。除此以外,在函数被调用时,其参数也会被压入发起调用的进程栈中,并且待到调用结束后,函数的返回值也会被存放回栈中。由于栈的先进先出特点,所以栈特别方便用来保存/恢复调用现场。从这个意义上讲,我们可以把堆栈看成一个寄存、交换临时数据的内存区。

       它是由操作系统分配的,内存的申请与回收都由OS管理。

     

    举个具体的C语言的例子吧:

    //main.c

    int a = 0; //全局初始化区

    char *p1; //全局未初始化区

    main()

    {

    static int c =0 //全局(静态)初始化区

    int b; //

    char s[] = "abc"; //

    char *p2; //

    char *p3 = "123456"; //"123456\0"在常量区,p3在栈上。

    p1 = (char *)malloc(10);

    p2 = (char *)malloc(20); //分配得来得1020字节的区域就在堆区。

    }

     

     

    二、各个段在内存中的组织

    各个段段在线性空间中的组织。直接上图:

    +--------------------------------   高地址

    + envstrings 环境变量字串    

    +--------------------------------

    + argv string 命令行字串        

    +--------------------------------

     

    + env pointers 环境变量指针表

    +--------------------------------

    + argv pointers命令行参数指针表

    +--------------------------------

    + argc 命令行参数个数

    +--------------------------------

     

    +     main函数的栈帧  

    +--------------------------------

    +     被调用函数的栈帧

    +--------------------------------

    +         ......                

    +--------------------------------



    +       (heap)                

    +--------------------------------



    + BSS 未初始化全局数据     

    +--------------------------------



    +   Data 初始化的全局数据    

    +--------------------------------

     

    +   Text 代码段                 

    +--------------------------------   

    其中,HeapBSSData这三个段在物理内存中是连续存放的,可以这么理解:这三个是一体的。TextStack是独立存放的,这是现在Linux中个段的分布,0.11中代码段和数据段不是分立的,是在一起的也就是说数据段和代码段是一个段,当然了,堆与BSS也与它们一起了。从0.11的task_struct中还可以看出数据段、堆栈段的描述符是一个,都在ldt[2]处。

     

    上图是进程的虚拟地址空间示意图。

    堆栈段:

      1. 为函数内部的局部变量提供存储空间。

      2. 进行函数调用时,存储“过程活动记录”。

      3. 用作暂时存储区。如计算一个很长的算术表达式时,可以将部分计算结果压入堆栈。

    数据段(静态存储区):

      包括BSS段的数据段,BSS段存储未初始化的全局变量、静态变量。数据段存储经过初始化的全局和静态变量。

    代码段:

      又称为文本段。存储可执行文件的指令。

    堆:

      就像堆栈段能够根据需要自动增长一样,数据段也有一个对象,用于完成这项工作,这就是堆(heap)。堆区域用来动态分配的存储,也就是用 malloc 函数活的的内存。calloc和realloc和malloc类似。前者返回指针的之前把分配好的内存内容都清空为零。后者改变一个指针所指向的内存块的大小,可以扩大和缩小,他经常把内存拷贝到别的地方然后将新地址返回。

     

     

     

    代码段、数据段、堆栈段,这是一个概念
    堆、栈、全局区、常量区,这是另一个概念

     

    1、栈区(stack):由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。 

    2、堆区(heap):由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事,分配方式倒是类似于链表。 

    3、全局区(静态区):全局变量和静态变量的存储是放在一块的,初始化的全局变量和静态变量在一块区域, 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 程序结束后由系统释放。 

    4、文字常量区:常量字符串就是放在这里的。 程序结束后由系统释放。 

    5、程序代码区:存放函数体的二进制代码。

     

     

     

    在进程被载入内存中时,基本上被分裂成许多小的节(section)。我们比较关注的是6个主要的节:

    (1) .text 节
        .text 节基本上相当于二进制可执行文件的.text部分,它包含了完成程序任务的机器指令。该节标记为只读,如果发生写操作,会造成segmentation fault。在进程最初被加载到内存中开始,该节的大小就被固定。

    (2).data 节
          .data节用来存储初始化过的变量,如:int a =0 ; 该节的大小在运行时固定的。

    (3).bss 节
        栈下节(belowstack section ,即.bss)用来存储为初始化的变量,如:int a; 该节的大小在运行时固定的。

    (4) 堆节
        堆节(heapsection)用来存储动态分配的变量,位置从内存的低地址向高地址增长。内存的分配和释放通过malloc() 和 free() 函数控制。

    (5) 栈节

        栈节(stacksection)用来跟踪函数调用(可能是递归的),在大多数系统上从内存的高地址向低地址增长。
    同时,栈这种增长方式,导致了缓冲区溢出的可能性。

    (6)环境/参数节
       环境/参数节(environment/argumentssection)用来存储系统环境变量的一份复制文件,进程在运行时可能需要。例如,运行中的进程,可以通过环境变量来访问路径、shell 名称、主机名等信息。该节是可写的,因此在格式串(format string)和缓冲区溢出(buffer overflow)攻击中都可以使用该节。
    另外,命令行参数也保持在该区域中。

    展开全文
  • 5个数据  进程(执行的程序)会占用一定数量的内存,它或是用来存放从磁盘载入的程序代码,或是存放取自用户输入的数据等等。...Linux进程的五个 下面我们来简单归纳一下进程对应的内存空间中所包含的5种

    5个数据段

           进程(执行的程序)会占用一定数量的内存,它或是用来存放从磁盘载入的程序代码,或是存放取自用户输入的数据等等。不过进程对这些内存的管理方式因内存用途 不一而不尽相同,有些内存是事先静态分配和统一回收的,而有些却是按需要动态分配和回收的。对任何一个普通进程来讲,它都会涉及到5种不同的数据段。

    Linux进程的五个段

    下面我们来简单归纳一下进程对应的内存空间中所包含的5种不同的数据区都是干什么的。

    BSS段:BSS段(bss segment)通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。

    数据段:数据段(data segment)通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。

    代码段:代码段(code segment/text segment)通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定,并且内存区域通常属于只读, 某些架构也允许代码段为可写,即允许修改程序。在代码段中,也有可能包含一些只读的常数变量,例如字符串常量等。

    堆(heap):堆是用于存放进程运行中被动态分配的内存段,它的大小并不固定,可动态扩张或缩减。当进程调用malloc等函数分配内存时,新分配的内存就被动态添加到堆上(堆被扩张);当利用free等函数释放内存时,被释放的内存从堆中被剔除(堆被缩减)

    栈(stack):栈又称堆栈, 是用户存放程序临时创建的局部变量,也就是说我们函数括弧“{}”中定义的变量(但不包括static声明的变量,static意味着在数据段中存放变量)。除此以外,在函数被调用时,其参数也会被压入发起调用的进程栈中,并且待到调用结束后,函数的返回值也会被存放回栈中。由于栈的先进先出特点,所以栈特别方便用来保存/恢复调用现场。从这个意义上讲,我们可以把堆栈看成一个寄存、交换临时数据的内存区。

    它是由操作系统分配的,内存的申请与回收都由OS管理。

    PS:

    全局的未初始化变量存在于.bss段中,具体体现为一个占位符;全局的已初始化变量存于.data段中;而函数内的自动变量都在栈上分配空间。.bss是不占用.exe文件空间的,其内容由操作系统初始化(清零);而.data却需要占用,其内容由程序初始化,因此造成了上述情况。

    bss段(未手动初始化的数据)并不给该段的数据分配空间,只是记录数据所需空间的大小。
    data(已手动初始化的数据)段则为数据分配空间,数据保存在目标文件中。 数据段包含经过初始化的全局变量以及它们的值。BSS段的大小从可执行文件中得到 ,然后链接器得到这个大小的内存块,紧跟在数据段后面。当这个内存区进入程序的地址空间后全部清零。包含数据段和BSS段的整个区段此时通常称为数据区。

    展开全文
  • BSS段:BSS段(bss segment)通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配...代码段代码段(code segment/text segment)通常是指用...

    BSS段:BSS段(bss segment)通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。

    数据段:数据段(data segment)通常是指用来存放程序中已初始化的全局变量的一块内存区域。数据段属于静态内存分配。

    代码段:代码段(code segment/text segment)通常是指用来存放程序执行代码的一块内存区域。这部分区域的大小在程序运行前就已经确定,并且内存区域通常属于只读, 某些架构也允许代码段为可写,即允许修改程序。在代码段中,也有可能包含一些只读的常数变量,例如字符串常量等。

    堆(heap):堆是用于存放进程运行中被动态分配的内存段,它的大小并不固定,可动态扩张或缩减。当进程调用malloc等函数分配内存时,新分配的内存就被动态添加到堆上(堆被扩张);当利用free等函数释放内存时,被释放的内存从堆中被剔除(堆被缩减)

    栈(stack):栈又称堆栈, 是用户存放程序临时创建的局部变量,也就是说我们函数括弧“{}”中定义的变量(但不包括static声明的变量,static意味着在数据段中存放变量)。除此以外,在函数被调用时,其参数也会被压入发起调用的进程栈中,并且待到调用结束后,函数的返回值也会被存放回栈中。由于栈的先进后出特点,所以栈特别方便用来保存/恢复调用现场。从这个意义上讲,我们可以把堆栈看成一个寄存、交换临时数据的内存区。

    它是由操作系统分配的,内存的申请与回收都由OS管理。

    注意:

    全局的未初始化变量存在于.bss段中,具体体现为一个占位符;全局的已初始化变量存于.data段中;而函数内的自动变量都在栈上分配空间。.bss是不占用可执行文件空间的,其内容由操作系统初始化(清零);而.data却需要占用,其内容由程序初始化,因此造成了上述情况。

    bss段(未手动初始化的数据)并不给该段的数据分配空间,只是记录数据所需空间的大小。
    data(已手动初始化的数据)段则为数据分配空间,数据保存在目标文件中。 数据段包含经过初始化的全局变量以及它们的值。BSS段的大小从可执行文件中得到 ,然后链接器得到这个大小的内存块,紧跟在数据段后面。当这个内存区进入程序的地址空间后全部清零。包含数据段和BSS段的整个区段此时通常称为数据区。

    展开全文
  • 简洁且成功的代码: hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ cat a.sh #!/bin/bash startTime=`date +"%s.%N"` #bwa aln ../GCA_000001405.15_GRCh38/GCA_000001405.15_GRCh38_...

    简洁且成功的代码:

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ cat a.sh 

    #!/bin/bash
    startTime=`date +"%s.%N"`
    #bwa aln ../GCA_000001405.15_GRCh38/GCA_000001405.15_GRCh38_full_analysis_set.fna ../SRR003161h20.fastq > SRR003161h20t1.sai
       for((i=1;i<=400;i++));do echo $(expr $i \* 4);done 
    endTime=`date +"%s.%N"` 
    echo `awk -v x1="$(echo $endTime | cut -d '.' -f 1)" -v x2="$(echo $startTime | cut -d '.' -f 1)" -v y1="$[$(echo $endTime | cut -d '.' -f 2) / 1000]" -v y2="$[$(echo $startTime | cut -d '.' -f 2) /1000]" 'BEGIN{printf "RunTIme:%.6f s",(x1-x2)+(y1-y2)/1000000}'`

    运行结果1:

    ... ...
    1568
    1572
    1576
    1580
    1584
    1588
    1592
    1596
    1600
    RunTIme:0.505397 s
    


    运行结果2(需要配置bwa程序):

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ ./a.sh 
    [bwa_aln] 17bp reads: max_diff = 2
    [bwa_aln] 38bp reads: max_diff = 3
    [bwa_aln] 64bp reads: max_diff = 4
    [bwa_aln] 93bp reads: max_diff = 5
    [bwa_aln] 124bp reads: max_diff = 6
    [bwa_aln] 157bp reads: max_diff = 7
    [bwa_aln] 190bp reads: max_diff = 8
    [bwa_aln] 225bp reads: max_diff = 9
    [main] Version: 0.7.12-r1039
    [main] CMD: bwa aln ../GCA_000001405.15_GRCh38/GCA_000001405.15_GRCh38_full_analysis_set.fna ../SRR003161h20.fastq
    [main] Real time: 36.195 sec; CPU: 3.575 sec
    RunTIme:36.265438 s
    
    可以看出来调用程序时间稍大于程序内部自己内测时间,正常。

    程序说明:

    startTimeS1=$(echo $startTime | cut -d '.' -f 1)
    startTimeS2=$[$(echo $startTime | cut -d '.' -f 2) /1000]
    endTimeS1=$(echo $endTime | cut -d '.' -f 1)
    endTimeS2=$[$(echo $endTime | cut -d '.' -f 2) / 1000]
    

    详细可参考最后一个调试(调试5)

    总结:参考指令

    awk

    |bc

    expr

    $[]

    毫秒和纳秒时间可调。

    可以忽略一下,仅自己参考、记录

    调试1(有错误):

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ cat a.sh 
    #!/bin/bash
    startTime=`date +"%Y-%m-%d %H:%M:%S.%N"`
       for((i=1;i<=10;i++));do echo $(expr $i \* 4);done
    endTime=`date +"%Y-%m-%d %H:%M:%S.%N"` 
    echo "startTime "$startTime
    echo "endTime "$endTime
    startTimeS1=$(echo $startTime | cut -d '.' -f 1)
    startTimeS2=$(echo $startTime | cut -d '.' -f 2)
    #startTimeS1= cut -d '.' -f 1 $startTime
    #startTimeS2= cut -d '.' -f 2 $endTime
    
    endTimeS1=$(echo $endTime | cut -d '.' -f 1)
    endTimeS2=$(echo $endTime | cut -d '.' -f 2)
    echo $startTimeS1
    echo $endTimeS1
    echo $startTimeS2
    echo $endTimeS2
    
    startTimeS1Linux=`date -d  "$startTimeS1" +%s`    #把当前时间转化为Linux时间
    endTimeS1Linux=`date -d  "$endTimeS1" +%s`
    startTimeS2Linux=`date -d  "$startTimeS2" +%s`    #把当前时间转化为Linux时间
    endTimeS1L2nux=`date -d  "$endTimeS2" +%s`
    echo $startTimeS1Linux
    echo $endTimeS1Linux
    echo $startTimeS2Linux
    echo $endTimeS2Linux
    s=`expr  $endTimeS1Linux - $startTimeS1Linux`  #计算2个时间的差
    #ns=`expr $endTimeS2Linux - $startTimeS2Linux`  #计算2个时间的差
    ns=`expr $endTimeS2 - $startTimeS2`  #计算2个时间的差
    echo $s.$ns
    

    运行结果:

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ ./a.sh 
    4
    8
    12
    16
    20
    24
    28
    32
    36
    40
    startTime 2016-03-14 21:46:10.065302995
    endTime 2016-03-14 21:46:10.078381939
    2016-03-14 21:46:10
    2016-03-14 21:46:10
    065302995
    078381939
    date: invalid date ‘065302995’
    date: invalid date ‘078381939’
    1457963170
    1457963170
    
    
    0.13078944

    调试2(有错误):

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ cat a.sh 
    #!/bin/bash
    startTime=`date +"%Y-%m-%d %H:%M:%S.%N"`
       for((i=1;i<=10;i++));do echo $(expr $i \* 4);done
    endTime=`date +"%Y-%m-%d %H:%M:%S.%N"` 
    startTimeS1=$(echo $startTime | cut -d '.' -f 1)
    startTimeS2=$(echo $startTime | cut -d '.' -f 2)
    endTimeS1=$(echo $endTime | cut -d '.' -f 1)
    endTimeS2=$(echo $endTime | cut -d '.' -f 2)
    startTimeS1Linux=`date -d  "$startTimeS1" +%s`    #把当前时间转化为Linux时间
    endTimeS1Linux=`date -d  "$endTimeS1" +%s`
    echo "RunTime:"`expr  $endTimeS1Linux - $startTimeS1Linux`.`expr $endTimeS2 - $startTimeS2`"s"
    
    输出:

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ ./a.sh 
    4
    8
    12
    16
    20
    24
    28
    32
    36
    40
    RunTime:0.13458804s
    

    调试3(有错误):

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ cat a.sh 
    #!/bin/bash
    startTime=`date +"%s.%N"`
       for((i=1;i<=10;i++));do echo $(expr $i \* 4);done
    endTime=`date +"%s.%N"` 
    startTimeS1=$(echo $startTime | cut -d '.' -f 1)
    startTimeS2=$(echo $startTime | cut -d '.' -f 2)
    endTimeS1=$(echo $endTime | cut -d '.' -f 1)
    endTimeS2=$(echo $endTime | cut -d '.' -f 2)
    echo "RunTime:"`expr  $endTimeS1 - $startTimeS1`.`expr $endTimeS2 - $startTimeS2`"s"
    
    输出:

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ ./a.sh 
    4
    8
    12
    16
    20
    24
    28
    32
    36
    40
    RunTime:0.13124421s
    
    <span style="font-size: 13.3333px;">调试4(有错误):</span>
    
    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ cat a.sh 
    #!/bin/bash
    startTime=`date +"%s.%N"`
       for((i=1;i<=10;i++));do echo $(expr $i \* 4);done
    endTime=`date +"%s.%N"` 
    echo "RunTime:"`expr $(echo $endTime | cut -d '.' -f 1) - $(echo $startTime | cut -d '.' -f 1)`.`expr $(echo $endTime | cut -d '.' -f 2) - $(echo $startTime | cut -d '.' -f 2)`"s"


    输出:

    hadoop@Mcnode1:~/cloud/adam/xubo/data/test20160310/test$ ./a.sh 
    4
    8
    12
    16
    20
    24
    28
    32
    36
    40
    RunTime:0.13331374s


    前面几种没有考虑结束的纳秒比开始的纳秒小,会出现负数,故需要修改:

    调试5(有错误):

    #!/bin/bash
    #echo "hello"
    #bwa aln ../GCA_000001405.15_GRCh38/GCA_000001405.15_GRCh38_full_analysis_set.fna ../SRR003161h20.fastq > SRR003161h20t1.sai
    startTime=`date +"%s.%N"`
     bwa aln ../GCA_000001405.15_GRCh38/GCA_000001405.15_GRCh38_full_analysis_set.fna ../SRR003161h20.fastq > SRR003161h20t1.sai
    #   for((i=1;i<=400;i++));do echo $(expr $i \* 4);done
    endTime=`date +"%s.%N"` 
    echo "startTime "$startTime
    echo "endTime "$endTime
    startTimeS1=$(echo $startTime | cut -d '.' -f 1)
    startTimeS2=$[$(echo $startTime | cut -d '.' -f 2) /1000]
    endTimeS1=$(echo $endTime | cut -d '.' -f 1)
    endTimeS2=$[$(echo $endTime | cut -d '.' -f 2) / 1000]
    #echo $Scha
     #echo `awk -v x1="$endTimeS1" -v x2="$startTimeS1" -v y1="$endTimeS2" -v y2="$startTimeS2" 'BEGIN{printf "product0:1-%f,2-%.3f,sum-%.3f",x1-x2,y1-y2,(x1-x2)+(y1/1000-y2/1000)}'`
     echo `awk -v x1="$endTimeS1" -v x2="$startTimeS1" -v y1="$endTimeS2" -v y2="$startTimeS2" 'BEGIN{printf "RunTIme:%.6f s",(x1-x2)+(y1-y2)/1000000}'`
     #echo $product0
    #if [ $endTimeS2 -lt $startTimeS2 ]; then
    # echo `awk -v x1="$endTimeS1" -v x2="$startTimeS1" -v y1="$endTimeS2" -v y2="$startTimeS2" 'BEGIN{printf "RunTIme:%.3f s",(x1-x2)+(y1/1000-y2/1000)}'`
    #echo  'awk -v x="$endTime" 'BEGIN{printf("%f",x*2}''
    #echo  "scale=3;$[$[$endTimeS2-1]-$startTimeS2]+$s2" |bc
    #echo "RunTime:" $ $[$(echo $endTime | cut -d '.' -f 1)-1] - $(echo $startTime | cut -d '.' -f 1) + $[$( $[ $(echo $endTime | cut -d '.' -f 2)+1000000000] - $(echo $startTime | cut -d '.' -f 2)) / 10000000 ]"s"
    #else
    #echo `awk -v x1="$endTimeS1" -v x2="$startTimeS1" -v y1="$endTimeS2" -v y2="$startTimeS2" 'BEGIN{printf "RunTIme:%.3f s",(x1-x2-1)+(y1/1000-y2/1000)}'`
    #echo "RunTime:" $[$[$endTimeS2-1]-$startTimeS2].$[$[$[$endTimeS1+1000]-$statTimeS1] / 1000] 
    #echo "RunTime:"`expr $(echo $endTime | cut -d '.' -f 1) - $(echo $startTime | cut -d '.' -f 1)`.`expr $(echo $endTime | cut -d '.' -f 2) - $(echo $startTime | cut -d '.' -f 2)`"s"
    #fi
    # exec_time_ms=$[$[$[ 10#$(echo $endTime | cut -d '.' -f 1) - 10#$(echo $startTime | cut -d '.' -f 1)] * 1000] + $[$[10#$(echo $endTime | cut -d '.' -f 2) / 1000000] - $[10#$(echo $startTime | cut -d '.' -f 2) / 1000000] ] ]
    # nowdate=`date +%Y%m%d-%T`
    # echo "--------$nowdate-------->":$exec_time_ms 
    #current=`date "+%Y-%m-%d %H:%M:%S"`     #获取当前时间,例:2015-03-11 12:33:41       
    #timeStamp=`date -d "$current" +%s`      #将current转换为时间戳,精确到秒
    #currentTimeStamp=$((timeStamp*1000+`date "+%N"`/1000000)) #将current转换为时间戳,精确到毫秒
    #echo $currentTimeStamp
    


    shell运算参考:【4】

    虽然Bash shell 有四种算术运算方法,但并不是每一种都是跨平台的,建议使用expr。
    另外,我们在 script 中经常有加1操作,以下四法皆可:
    m=$[ m + 1]
    m=`expr $m + 1`
    m=$(($m + 1))
    let m=m+1
    另外,还可以使用bc
    m=`echo "( $a - 1 )*$b +1" |bc`


    参考文献:

    【1】  http://blog.csdn.net/foxliucong/article/details/4225008

    【2】 http://blog.csdn.net/gengshenghong/article/details/7583580

    【3】 http://blog.sina.com.cn/s/blog_9d074aae01012ytf.html
    【4】 http://blog.chinaunix.net/uid-209416-id-2410742.html

    【5】http://blog.jobbole.com/92430/

    【6】http://www.centoscn.com/shell/2013/0802/884.html


    展开全文
  • Linux错误代码及其含义

    万次阅读 多人点赞 2018-01-29 16:40:50
    最近在做工程的时候,程序在崩溃时候弹出了错误号,然后根据错误号搜索错误信息,很快解决之,特此记录。...Linux错误代码及其含义 C Name Value Description 含义 Success 0 Success 成功 EPERM 1
  • linux 下好用的 git 代码查看工具

    千次阅读 2017-07-19 15:53:36
    这就需要 git 代码查看工具来对比两个分支中当时同时修改了什么,该怎么合并 以前项目有 redmine git 网站,现在发现 giggle 或 gitg 也很好用,特此记录 注:个人更推荐 giggle,因为 gitg 查看代码时并不能查找...
  • 如何查看linux命令源代码

    千次阅读 2010-08-07 20:45:00
    linux时间了,有时候想看看ls、cat、more等命令的源代码,在下载的内核源码中用cscope没能找到,在网上搜索了一下,将方法总结如下:  1. 以搜索ls命令源码为例,先搜索命令所在包,命令如下:  lpj@lpj-...
  • 在介绍这一跳转之前,这篇文章我们来介绍两个概念:一致代码段和非一致代码段。 首先,我们先来看几个问题: 一致代码段和非一致代码段是什么? 为什么要有一致代码段和非一致代码段? 系统提供怎样的机制来使用户...
  • linux时间了,有时候想看看ls、cat、more等命令的源代码,在下载的内核源码中用cscope没能找到,在网上搜索了一下,将方 法总结如下: 以搜索ls命令源码为例,先搜索命令所在包,命令如下: [Java]...
  • Linux代码下载

    千次阅读 2012-02-25 10:00:26
    1. 课程设计题目:下载某个版本的linux代码,生成一个定制的linux操作系统,完成后该系统可以用来作为启动系统使用。 2.如何做的问题? 内核版本 要编译一个最新的内核,您需要首先下载它的源代码 在您下载...
  • Linux内核代码风格

    万次阅读 2011-03-08 10:27:00
    Linux内核代码风格 By Linus Torvalds
  • 查看 linux 命令源代码的方法

    千次阅读 2013-07-05 14:50:02
    linux时间了,有时候想看看ls、cat、more等命令的源代码,在下载的内核源码中用cscope没能找到,在网上搜索了一下,将方 法总结如下:查看代码主要有两种方式: 基于debian的: 以搜索ls命令源码为例,...
  • Linux系统查看历史用户的指令、代码

    千次阅读 2017-04-06 10:43:32
    查看Linux系统的用户进程,历史操作指令,和记录用户登录代码
  • 使用VS2017调试Linux C++代码

    万次阅读 2017-11-12 17:26:02
    VS2017版本现已支持开发Linux项目,就是在VS上面写代码,而编译和运行是在Linux环境下。 使用场景: 假如,代码最终是运行在Linux系统上,而我们又不想在Linux环境下写代码,想借用VS强大的开发功能做开发,那么...
  • 其实在程序运行时,由于内存的管理方式是以页为单位的,而且程序...而且代码和数据是分开存放的,即不储存于同于一个中,而且各种数据也是分开存放在不同的中的。 5个 进程(执行的程序)会占用一定数量的内
  • linux下测试一段代码的执行时间

    千次阅读 2012-04-19 11:06:20
    下面代码用于在linux下测试一段代码的执行时间(应用层的) ################################################################ #include #include void function(void) { unsigned int i,j; double y;
  • Linux启动代码header.S研究

    千次阅读 2010-12-19 18:17:00
    Linux启动代码header.S研究
  • 最近刚刚从 Windows 平台转向 Linux 平台,涉及到 Linux 平台上 C++ 项目代码的修改工作。为了方便,我们还是在 Windows 平台上使用 ssh 到服务器进行代码查看修改。这里,我注意到老员工是直接在服务器上使用 vi ...
  • 代码段数据段的位置

    千次阅读 2011-06-08 09:30:00
    最近读linux源码,遇到问题:bios是在把bootsect.s加载到0x7c00处,怎么把指挥权交给bootsect.s呢,换句话说,bios怎么知道bootsect.s的代码段第一条指令在哪呢?这个问题困扰着我有一夜。。。不解决这个问题,心有...
  • linux内存及命令行下查看

    千次阅读 2013-12-31 17:47:42
    BSS段:BSS段(bss segment)通常是指用来存放程序中未初始化的全局变量的一块内存区域。BSS是英文Block Started by Symbol的简称。BSS段属于静态内存分配。...代码段代码段(code segment/text segment)通常是指用
  • Linux代码覆盖率工具:gcov

    千次阅读 2017-09-17 13:34:14
    Linux代码覆盖率工具:gcov 对于C/C++软件开发,常常需要通过代码覆盖率报告来了解测试用例的场景覆盖情况,对于测试用例未覆盖的代码分支流程,需要补充用例,以保证测试用例的全面性与完整性,不漏测任何一个...
  • 微软为何贡献Linux代码

    千次阅读 热门讨论 2009-07-22 05:40:00
    <!-- @page { margin: 2cm } P { margin-bottom: 0.21cm } --> 毫无疑问,Linux是微软的竞争对手。但是,微软为什么还要给Linux贡献驱动源代码,助Linux一臂之力?岂非头脑发疯了?事实究竟是怎样的? 
  • linux内核代码数量增长情况

    千次阅读 2013-01-08 18:17:00
    版本 3.3 是第一个超过 1500 万行代码Linux 版本(采用了一种确实存在缺陷的测量方法测量的)。如果减去 Linux 内核的变体部分(比如驱动程序、架构相关代码和各种工具),数量可能会下降到 400 万以下(仍然是一...
  • chrome 从任何页面运行代码段

    千次阅读 2017-12-16 13:22:55
    创建代码段 运行代码段 查看本地修改 设置断点概览代码段是您可以在 Chrome DevTools 的 Sources 面板中制作和执行的小脚本。 您可以从任何页面访问和运行它们。 在您运行代码段时,它会从当前已打开页面的上下文...
  • Linux查看占用CPU过高的代码

    千次阅读 2019-08-20 21:34:35
    要查询是哪块儿代码的问题,Linux系统层面的几个追踪命令,strace,ltrace,都可以,另外你可以借助PHP性能追踪及分析工具xhprof,另外几个建议,1、开启fpm慢日志查看2、开启MySQL慢日志,查看系统io情况3、优化,...
  • 文件格式 现在PC平台流行的可执行程序格式,主要是Windows下...一般情况下,一个可执行二进制程序(更确切的说,在Linux操作系统下为一个进程单元)在存储(没有调入到内存运行)时拥有3个部分,分别是代码段(text)、数...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 504,563
精华内容 201,825
关键字:

linux查看代码段

linux 订阅