DMA(Direct Memory Access)简介

DMA(Direct Memory Access)是指在现代计算机系统上,外接设备可以不用CPU干预,直接把数据传输到内存的技术。

DMA控制器(controller)是一种特殊的硬件,它用来管理数据传输和总线仲裁。当要发起数据传输时,它会发一个申请使用系统总线的DMA请求信号给CPUCPU完成当前操作后,就会让出系统总线,同时会发一个DMA确认信号给DMA控制器。接下来,DMA控制器接管系统总线,开始数据传输。数据传输完毕后,DMA控制器会通知CPU重新接管总线。

正常情况下,CPU全权负责内存的读写操作,而DMA技术可以把CPU解放出来,这将使计算机性能得到显著改善。

参考资料:
DMA (Direct Memory Access)

硬件虚拟化(hardware virtualization)浅析

硬件虚拟化(hardware virtualization)可以创建出多个系统虚拟机实例(system virtual machine instance),这些虚拟机可以运行整个操作系统(包括它们的内核)。硬件虚拟化分为以下几种:

a)Full virtualization - binary translation:提供一个由虚拟化硬件部件组成完整的虚拟化系统,可以在上面安装一个不需修改的,完整的操作系统。这项技术结合了直接的处理器执行和必要时指令的二进制转化(binary translation)。

b)Full virtualization - hardware-assisted:提供一个由虚拟化硬件部件组成完整的虚拟化系统,可以在上面安装一个不需修改的,完整的操作系统。这项技术利用了处理器的支持,使得执行虚拟机更加有效率(比如AMD-VIntel-VT扩展)。

c)Paravirtualization:提供一个支持接口(interface)的虚拟系统,虚拟机操作系统(guest OS)利用这个接口就可以有效地利用宿主机(host)资源(通过hypercalls),而不需要所有组件的完全虚拟化。

还有一种hybrid virtualization,利用hardware-assisted virtualization加上一些高效的paravirtualization调用,可以提供更好的性能(performance)。

Hypervisor(或被称为Virtual Machine Monitor (VMM))是用来创建虚拟机的,它可以由软件(software),硬件(hardware)或固件(firmware)实现。有2种类型的hypervisor,请参考下图:

hypervisor

类型1)这种hypervisor直接运行在处理器上 (例如:hyper-VKVM ,也被称之为native hypervisorbare-metal hypervisorHypervisor的管理工作是通过一个享有特权模式的guest OS来进行(在上图中,为Guest OS #0),这个guest OS可以创建和启动其它的guest OS

类型2)这种hypervisor运行在宿主机操作系统上 (例如:VirtualBox 。由宿主机操作系统负责管理hypervisor和启动新的guest OS

参考资料:
Systems Performance: Enterprise and the Cloud

Scala笔记(2)——val和var

Scala中,用val声明一个变量是不可改变的(immutable,read-only),而用var声明一个变量是可改变的(immutable,read-write)。同Java类似,Scala中许多变量实质上对分配在堆(heap)上的对象(object)的引用(reference),所以可变或不可变指的是引用可不可以指向不同的对象,而并非指引用的对象本身是否可以改变。看下面这个例子:

scala> val array: Array[String] = new Array(5)
array: Array[String] = Array(null, null, null, null, null)

scala> array[0] = "Hello"
<console>:1: error: identifier expected but integer literal found.
       array[0] = "Hello"
             ^

scala> array = new Array(2)
<console>:8: error: reassignment to val
       array = new Array(2)
             ^

array是一个val类型变量,array所指向数组的第一个元素可以改变(array[0] = "Hello"),但是array不能指向一个新的数组(array = new Array(2))。

BPF(BSD Packet Filter)简介

BPF(BSD Packet Filter)是一种抓取并过滤网络数据包(capture and filter packet)的内核结构(kernel architecture)。BPF包含2个重要的组成部分:网络分流器(network tap)和包过滤器(packet filter)。网络分流器负责从网络驱动拷贝数据包,而包过滤器则过滤掉不符合条件的数据包,只把符合需求的数据包上报给应用程序。下图摘自UNP

BPF

当数据包到达网卡时,正常情况下,数据链路层的驱动程序会把包转给协议栈。但当有BPF监听网卡时,驱动程序会首先把包发给BPFBPF会把包发给不同程序的包过滤器,再由过滤器决定哪些包并且包里的哪些内容应该保存下来。对于符合条件的数据包,BPF会把数据拷贝到和包过滤器对应的缓存(buffer)。然后驱动程序继续执行。

在用tcpdump命令过滤数据包时:

tcpdump -p -ni eth0 -d "ip and udp"

实际就用到了BPF

Scala笔记(1)——一个入门的Scala程序

这是一个简单的入门Scala程序(iterate.scala):

object Iterate {
  def main (args: Array[String]) {
    args.foreach(s => println(s))
  }
}

在程序中,Iterate被定义成objectScalaobjectsingleton,也就是运行时只能产生一个Iterate实例。

main方法只能定义在object中,传入到main方法中的命令行参数是一个字符串数组:args: Array[String]main方法可以看成是Java类的static main方法,即Iterate程序的入口函数。

s => println(s)是一个functional literal,做的仅仅是打印s而已。

执行这个程序:

[root@Fedora scala]# scala iterate.scala  1 2
1
2

可以看出打印了命令行参数。

如何运行scala脚本

搭建Scala开发环境一文中可以看到不加任何参数直接运行scala命令时,会启动REPL(Read,Eval,Print,Loop)环境,然后就可以在这个环境里交互地执行Scala代码。本文介绍如何运行Scala脚本(script)。

首先创建一个简单的Scala脚本(hello.scala):

print("Hello world!\n")

a)直接运行scala hello.scala

[root@Fedora scala]# scala hello.scala
Hello world!

b)在REPL环境用load命令运行hello.scala

[root@Fedora scala]# scala
Welcome to Scala version 2.10.4 (OpenJDK 64-Bit Server VM, Java 1.8.0_45).
Type in expressions to have them evaluated.
Type :help for more information.

scala> :load hello.scala
Loading hello.scala...
Hello world!

c)如果想把脚本编译成JVM byte code (一组*.class文件),可以使用scalac程序(命令行选项是-Xscript <object><object>是“main class”的名字,也即Java程序的入口):

[root@Fedora scala]# scalac -Xscript hello hello.scala
[root@Fedora scala]# ls
hello$$anon$1.class  hello.class  hello$.class  hello.scala
[root@Fedora scala]# scala hello
Hello world!

也可以用scalap这个逆向分析工具分析一下hello.class

[root@Fedora scala]# scalap -cp . hello
object hello extends scala.AnyRef {
  def this() = { /* compiled code */ }
  def main(argv : scala.Array[scala.Predef.String]) : scala.Unit = { /* compiled code */ }
}

Lua笔记(7)——luaL_loadfile和luaL_dofile的区别

luaL_loadfile()会加载和编译Lua脚本,但不会运行。而luaL_dofile不仅运行编译后的脚本,运行结束后还会把脚本pop出栈。看下面这个例子:

一个简单的脚本(test.lua):

print "Hello World!"

首先看调用luaL_loadfile()的程序:

#include <stdio.h>
#include <stdlib.h>
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

static void stackDump(lua_State *L)
{
    int i = 0;
    int type = 0;
    int top = lua_gettop(L);

    printf("There is %d elements in stack: ", top);
    for (i = 1; i <= top; i++)
    {
        type = lua_type(L, i);
        switch (type)
        {
            case LUA_TSTRING:
            {
                printf("'%s'", lua_tostring(L, i));
                break;
            }
            case LUA_TBOOLEAN:
            {
                printf(lua_toboolean(L, i) ? "true" : "false");
                break;
            }
            case LUA_TNUMBER:
            {
                printf("%g", lua_tonumber(L, i));
                break;
            }
            default:
            {
                printf("Element type is %s", lua_typename(L, type));
                break;
            }
        }
        printf(" ");
    }
    printf("\n");
    return;
}

static void bail(lua_State *L)
{
    fprintf(stderr, "\nFATAL ERROR:%s\n\n", lua_tostring(L, -1));
    exit(1);
}
int main(void)
{   
    lua_State *L = luaL_newstate();

    luaL_openlibs(L);

    if (luaL_loadfile(L, "test.lua"))
    {
        bail(L);
    }

    stackDump(L);

    lua_close(L);
    return 0;
}

执行结果:

[root@Fedora test]# ./a
There is 1 elements in stack: Element type is function

可以看到,并没有打印“Hello World!”,而且栈里还有一个类型为function的元素。

接下来看调用luaL_dofile()的程序:

#include <stdio.h>
#include <stdlib.h>
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

static void stackDump(lua_State *L)
{
    int i = 0;
    int type = 0;
    int top = lua_gettop(L);

    printf("There is %d elements in stack: ", top);
    for (i = 1; i <= top; i++)
    {
        type = lua_type(L, i);
        switch (type)
        {
            case LUA_TSTRING:
            {
                printf("'%s'", lua_tostring(L, i));
                break;
            }
            case LUA_TBOOLEAN:
            {
                printf(lua_toboolean(L, i) ? "true" : "false");
                break;
            }
            case LUA_TNUMBER:
            {
                printf("%g", lua_tonumber(L, i));
                break;
            }
            default:
            {
                printf("Element type is %s", lua_typename(L, type));
                break;
            }
        }
        printf(" ");
    }
    printf("\n");
    return;
}

static void bail(lua_State *L)
{
        fprintf(stderr, "\nFATAL ERROR:%s\n\n", lua_tostring(L, -1));
        exit(1);
}
int main(void)
{
    lua_State *L = luaL_newstate();

    luaL_openlibs(L);

    if (luaL_dofile(L, "test.lua"))
    {
        bail(L);
    }

    stackDump(L);

    lua_close(L);
    return 0;
}

执行结果:

[root@Fedora test]# ./a
Hello World!
There is 0 elements in stack:

可以看到,不仅打印了“Hello World!”,而且栈也变成了空。

参考资料:
lual_dofile(); wont load script with C++ and Lua

Lua笔记(6)——栈(stack)

C程序和Lua库之间通过栈(stack)来进行数据交换,并且栈中的每个槽位(slot)都能存放任意的Lua数据类型值。栈如下图所示:

                            |________|    <--  (-1)
                            |________|    <--  (-2)
                            |________|
                            | ...... |
                            |________|    <--  (2)
                            |________|    <--  (1)

栈底以1为起始索引,而栈顶则以-1作为起始索引。lua_gettop()函数可以返回当前栈中的元素个数,同时也是栈顶元素的索引值。如果是空栈,则 lua_gettop()返回0

Lua C API的核心就集中在对栈的操作上:当想要运行某个Lua脚本时,需要调用luaL_dofile()函数。而想执行Lua脚本的某个函数时,则首先要把函数push进栈(lua_getglobal()),如果函数需要参数,则参数也要相应地进栈(lua_pushXX())。接下来执行函数(比如lua_pcall()函数)。当函数退出时,返回值同样push进栈,C程序就可以使用lua_toXX()函数获得结果。请看下面这个例子:

一个简单的Lua脚本(test.Lua):

function add (a, b)
    return (a+b)
end

C程序如下:

#include <stdio.h>
#include <stdlib.h>
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

static void bail(lua_State *L)
{
    fprintf(stderr, "\nFATAL ERROR:%s\n\n", lua_tostring(L, -1));
    exit(1);
}
int main(void)
{   
    lua_State *L = luaL_newstate();

    luaL_openlibs(L);

    if (luaL_dofile(L, "test.lua"))
    {
        bail(L);
    }

    lua_getglobal(L, "add");


    lua_pushnumber(L, 1);
    lua_pushnumber(L, 2);

    if (lua_pcall(L, 2, 1, 0))
    {
        bail(L);
    }

    printf("%g\n", lua_tonumber(L, -1));

    lua_close(L);
    return 0;
}

执行结果如下:

3

Go语言数组浅析

先看一个简单的数组定义:

var array [3]int

上面语句定义了变量array,这个变量是一个包含3个整数的数组类型。可以使用Go语言内置的len函数得到数组长度:

package main

import (
    "fmt"
)

func main() {
    var array [3]int
    fmt.Println(len(array))
}

执行以上程序结果:

3

需要注意的是,在Go语言中,数组的长度是数组类型的一部分,它必须是一个常量表达式,即长度的值在程序编译时是可以得到的。请看下面这个程序:

package main

import (
    "fmt"
)

func print_array(array []int) {
    fmt.Printf("In function, array is %v\n", array)
}

func main() {
    var array [3]int

    print_array(array )
}

编译这个程序会产生下面的错误:

main.go:14: cannot use array (type [3]int) as type []int in argument to print_array

Go语言要求传入函数的形参和实参的类型必须是完全匹配的,而array的类型是[3]int,不是[]int,所以编译会出错。

Go语言函数参数都是传值调用,所以如果函数的参数是数组的话,那么实际传入的将是原数组的拷贝。请看这个例子:

package main

import (
    "fmt"
)

func change_array(array [3]int) {
    for i, _ := range array {
        array[i] = 1
    }
    fmt.Printf("In function, array address is %p, value is %v\n", &array, array)
}

func main() {
    var array [3]int

    fmt.Printf("Original array address is %p, value is %v\n", &array, array)
    change_array(array)
    fmt.Printf("Changed array address is %p, value is %v\n", &array, array)
}

执行结果:

Original array address is 0xc082006560, value is [0 0 0]
In function, array address is 0xc0820065e0, value is [1 1 1]
Changed array address is 0xc082006560, value is [0 0 0]

可以看到,在change_array函数中操作的数组地址并不是main函数中的数组地址,而main函数中的数组的值在调用change_array函数前后也没有发生变化。

如果数组的元素类型是可比较的,那么数组类型就是可比较的,即可以使用“==”和“!=”运算符对数组进行运算。 请看下例:

package main
import "fmt"

func main()  {
    a := [...]int{2, 1}
    b := [...]int{1, 2}
    fmt.Println(a == b, a != b)
}

执行结果如下:

false true

 

如何编译使用Lua库的C程序

编写使用LuaC程序后,除了需要链接Lua库以外,还需要链接libmlibdl。以下面程序为例(test.c):

#include <stdio.h>
#include <stdlib.h>
#include "lua.h"
#include "lauxlib.h"
#include "lualib.h"

int main(void)
{
    char buf[256] = {0};
    int error = 0;

    lua_State *L = luaL_newstate();
    luaL_openlibs(L);

    while (fgets(buf, sizeof(buf), stdin) != NULL)
    {
        error = luaL_loadstring(L, buf) || lua_pcall(L, 0, 0, 0);
        if (error)
        {
            fprintf(stderr, "Error is %s.\n", lua_tostring(L, -1));
            lua_pop(L, 1);
        }
    }
    lua_close(L);
    return 0;
}

编译:

[root@Fedora test]# gcc -g -o test test.c -llua -lm -ldl

执行:

[root@Fedora test]# ./test
print("hello")
hello
^C
[root@Fedora test]#