目录
 
​
 
​1.时钟周期、振荡周期、节拍周期
 
2.状态周期
 
3.机器周期、CPU周期
 
4.指令周期
 
5.总线周期
 
总结
 
微信公众号
 

 
 
 
​1.时钟周期、振荡周期、节拍周期
 
　　时钟周期又叫做振荡周期、节拍周期，定义为时钟晶振频率的倒数。时钟周期是计算机中最基本的、最小的时间单位。在一个时钟周期内，CPU仅完成一个最基本的动作。例如晶振为12M，则时钟周期为1/12us。又可以被定义为节拍。
 
2.状态周期
 
    状态周期是时钟周期的2倍，由时钟周期二分频得到。
 
    在8051单片机中把一个时钟周期定义为一个节拍（用P表示），二个节拍定义为一个状态周期（用S表示）。
 
    8051系列单片机的一个机器周期同6个S周期（状态周期）组成。一个机器周期包含6个状态周期（S1-S6）,而一个状态周期又包含两个时钟振荡周期（简称时钟周期）。例：8051单片机的机器周期由6个状态周期组成，也就是说一个机器周期=6个状态周期=12个时钟周期。
 
3.机器周期、CPU周期
 
　　在计算机中，为了便于管理，常把一条指令的执行过程划分为若干个阶段，每一阶段完成一项工作。例如，取指令、存储器读、存储器写等，这每一项工作称为一个基本操作。完成一个基本操作所需要的时间称为机器周期。一般情况下，一个机器周期由若干个S周期（状态周期）组成。比如，取值周期，取数周期。在80C51内部，机器周期一般包括于6个状态周期，12个时钟周期。例如24M的晶振，机器周期为12/24M秒。
 
4.指令周期
 
　　指令周期是指取出并完成一条指令所需的时间，一般由若干个机器周期组成，分为单周期指令，双周期指令和多周期指令。
 
　　对于一些简单的的单字节指令，在取指令周期中，指令取出到指令寄存器后，立即译码执行，不再需要其它的机器周期。对于一些比较复杂的指令，例如转移指令、乘法指令，则需要两个或者两个以上的机器周期。　　
 
5.总线周期
 
　　由于存贮器和I/O端口是挂接在总线上的，CPU对存贮器和I/O接口的访问，是通过总线实现的。通常把CPU通过总线对微处理器外部（存贮器或 I/O接口）进行一次访问所需时间称为一个总线周期。一个总线周期一般包含4个时钟周期，这4个时钟周期分别称4个状态即T1状态、T2状态、T3状态和 T4状态。
 
 
总结
 
时钟周期=T
 
状态周期=2*T
 
总线周期=4*T
 
机器周期=若干状态周期
 
指令周期=若干机器周期
 
 
 
微信公众号
 
     建立了一个微信公众号“Andy的ICer之路”，此公众号主要分享数字IC相关的学习经验，文章主要在公众号上发，csdn会尽量同步更新，有兴趣的朋友可以关注一下！
 

 
 
 
  
第一部分
 
  
最近在写Python的时候发现一个好玩的现象，就是在if else重定义的变量，没有声明全局，在外部也可以使用，
 
  
这里涉及到一个python变量生命周期的问题。
 
  
python能够改变变量作用域的代码段是def、class、lamda.
 
  
if/elif/else、try/except/finally、for/while 并不能涉及变量作用域的更改，
 
  
也就是说他们的代码块中的变量，在外部也是可以访问的
 
  
变量搜索路径是：本地变量->全局变量
 
  
https://img-blog.csdn.net/20161110105647895?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
 
  
http://blog.csdn.net/u012965373/article/details/53113586
 
  
第二部分
 
  
python中，对于变量作用域的规定有些不一样。在诸如C/C++、java等编程语言中，默认在函数的内部是可以直接访问在函数外定义的全局变量的，但是这一点在python中就会有问题，下面是一个例子。
 
  
test.py:
#!/usr/bin/python

COUNT=1

def func():
    COUNT = COUNT + +1

func()
Python test.py，会运行报错：
Traceback (most recent call last):
  File "test.py", line 8, in 
    func()
  File "test.py", line 6, in func
    COUNT = COUNT + +1
UnboundLocalError: local variable 'COUNT' referenced before assignment
 
  
“UnboundLocalError: local variable 'COUNT' referenced before assignment”的意思是变量COUNT在赋值之前被引用。
 
  
这里要知道python和其它编程语言不一样的地方。像C/C++之类的编程语言，变量名称实际上是代表的一块内存区域，对该变量赋值的意思就是将新的值放入该变量指定的内存区域。而对于python来说，所有的变量都是对内存区域的引用，对变量赋值相当于将变量引用的内存从一块区域改变到另外一块存放新值的区域。也就是说，C/C++中，变量名和内存区域的对应关系不会变，变的只是对应内存中存放的值；而在python中，变量只是对存放其值的内存区域的引用，变量值的改变不是因为变量指向的内存区域中的值发生了变化，而是变量引用了新的存放新值的内存区域。python中的所有变量都是相当于java中的不可变的变量，任何一次值的改变都对应着变量引用内存区域的变化。区别如下图1：
 
  
 
  
图1 变量的比较
 
  
python中有一个id函数，python中有一个id函数，help(id)可以看到它的说明，如下：
 
  
Help on built-in function id in module __builtin__:
id(...)
    id(object) -> integer    
    Return the identity of an object.  This is guaranteed to be unique among simultaneously existing objects.(Hint: it's the object's memory address.)
(END)
 
  
简单地说，id函数反应的是对象的内存地址，看下面的实验结果：
 
  
test.py：
#!/usr/bin/python

COUNT = 1 
for i in range(5):
    COUNT = COUNT + 1 
    print id(COUNT)

python test.py运行结果：
11031328
11031304
11031280
11031256
11031232
 
  
这里和上面图上说明的相吻合，python中每一次赋值都使变量引用的内存空间发生了改变。
 
  
回到上面“referenced before assignment”的错误，之所以会发生这种错误是因为python在函数中发现对于COUNT变量的赋值，会将其添加到函数的局部命名空间（实际上，这是在函数运行到赋值操作之前发生的）。进行赋值操作时，赋值操作符的右边引用了COUNT变量，而这时COUNT变量只是被添加到了函数的局部命名空间，而没有被具体赋值，所以会发生上面的错误。实际上，这里问题就出在赋值操作的地方，因为有赋值操作导致该变量被添加到了函数的局部命名空间。如果没有赋值，只是引用该变量，是没有什么问题的，如下：
 
  
test.py：
#!/usr/bin/python

COUNT=1

def func():
    temp = COUNT + 1 
    print "temp:",COUNT
    print "COUNT:",COUNT

func()

python test.py运行结果：
temp: 1
COUNT: 1
 
  
这样，COUNT变量没有被添加到函数的局部命名空间，python解释器在函数的局部命名空间中没有查找到它，然后，python解释器会继续在全局的命名空间中查找，结果在全局命名空间中找到COUNT的定义并引用它的值，所以程序运行没有任何问题。
 
  
到这里你可能会问，难道在函数中没法修改全局变量的值吗？不是的，如果要在函数中修改全局变量的值，就要在函数中对该变量进行global声明，以告诉python解释器，该变量是全局命名空间中的，如下：
 
  
test.py：
#!/usr/bin/python

COUNT=1

def func():
    global COUNT
    COUNT = COUNT + 1 
    print "COUNT:",COUNT

func()

python test.py运行结果：
COUNT: 2
 
 
 
 
 
 
 

时钟周期：
 
又叫振荡周期；是时钟脉冲的倒数；例如22.1184MHz的控制器，其时钟周期就是1/22.1184 us.
 
 
 
状态周期：
 
8051把1个时钟周期叫做一个节拍。两个节拍定义为一个状态周期。
 
 
 
机器周期：
 
完成一个基本操作的时间单元叫做机器周期。一个机器周期由若干个状态周期构成。8051的机器周期一般由6个状态周期构成，即12个时钟周期。
 
 
 
指令周期：
 
完成一条指令所需的时间。简单的指令是单机器周期指令；复杂的双机器周期指令和多机器周期指令。
 
指令周期是CPU的关键指标。ARM的指令一般都是单周期指令。
 
 
 
 
 
STC单片机下载时有一个12T和6T模式选择。12T就是普通的模式，指令周期的时间等于时钟周期的12倍。而6T则是倍速模式，指令周期的时间等于时钟周期的6倍。两者的区别会在串口速度上面有体现。同样的code，以6T模式和以12T模式下载后，串口波特率相差一倍。
 
 
 
1T是12倍速的模式，即指令周期的时间与时钟周期相等。
 
 

这个很少被人意识到，2个分别对应到c头文件定义和c++头文件定义，日常使用没有影响是因为先包含的会使后续包含定义触发条件编译，而且经常using namespace std;使不区分std:size_t。做为一个优秀的代码输出者，要严谨的弄清楚，有针对性的处理，提高代码质量，降低代码开发周期。
 

 
 
结论：c和C++混编，尤其是跨平台时，一定要注意头文件包含顺序，如果是c++，最早的包含c++的头文件，如果是c，则晚一些包含c++头文件，这是有差异的，不保证完全等价。
 

 
 
第一部分，影响：
 
对于业务逻辑，包括typeid等，都没有影响，因为条件编译是预处理阶段完成，编译阶段面对的已经是基础类型定义。
 
但是，毕竟两个文件是独立的，在跨平台编译等情况下，类型定义仅为了保证长度相等，两个文件可能会产生定义差异，导致类型不匹配，比如
 
 
#include <iostream>
#include <typeinfo>
using namespace std;

typedef long long  type1;
typedef int64_t type2;

int main()
{
        type1 s1 = 0;
        type2 s2 = 0;
        cout << sizeof(type1) << " " << sizeof(type2) << endl;
        cout << (typeid(s1) == typeid(s2) ? "eq" : "nq") << endl;
        cout << typeid(s1).name() << endl;
        cout << typeid(s2).name() << endl;
        return 0;
}
输出
8 8
nq
x
l
 
这与逻辑是对不上的，位长一样，符号一样，却是不同的类型。
 

 
 
第二部分，验证一下区别，通过将size_t重定义产生冲突报错来查看定义源
 

#include <stdio.h>
typedef bool size_t;
int main()
{
                return 0;
}
 
编译报错：
 main.cpp:3:14: error: conflicting declaration ‘typedef bool size_t’

  typedef bool size_t;

               ^

 In file included from /usr/include/stdio.h:34:0,

                  from main.cpp:1:

 /opt/rh/devtoolset-2/root/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h:212:23: error: ‘size_t’ has a previous declaration as ‘typedef long unsigned int size_ ’

  typedef __SIZE_TYPE__ size_t;

                        ^

 make: *** [main] Error 1

 继续追踪：

 /opt/rh/devtoolset-2/root/usr/lib/gcc/x86_64-redhat-linux/4.8.2/include/stddef.h:209:#define __SIZE_TYPE__ long unsigned int

 
所以C头文件定义是：long unsigned int
 

 
 
再来看一下c++定义
 
#include <iostream>
using namespace std;
namespace std
{
        typedef bool size_t;
}
int main()
{
        return 0;
}
编译报错

 main.cpp:7:15: error: conflicting declaration ‘typedef bool std::size_t’

   typedef bool size_t;

                ^

 In file included from /opt/rh/devtoolset-2/root/usr/include/c++/4.8.2/iostream:38:0,

                  from main.cpp:2:

 /opt/rh/devtoolset-2/root/usr/include/c++/4.8.2/x86_64-redhat-linux/bits/c++config.h:1857:26: error: ‘std::size_t’ has a previous declaration as ‘typedef long unsigned int std::size_t’

    typedef __SIZE_TYPE__  size_t;

                           ^

 make: *** [main] Error 1

 进一步追踪：

 bits/c++config.h:1764 if __cplusplus

 ...

 bits/c++config.h:1855 namespace std

 {

           typedef __SIZE_TYPE__     size_t;

             typedef __PTRDIFF_TYPE__  ptrdiff_t;

 

 

 #if __cplusplus >= 201103L

                   typedef decltype(nullptr) nullptr_t;

 #endif

 
}
 
这个做法非常聪明，直接使用了系统的__SIZE_TYPE__，所以必然和C一致