C++博客-GCC/GNU/Linux Delphi/Window Java/Anywhere

Linux 进程互斥锁

Khan's Notebook — Wed, 24 Dec 2008 02:45:00 GMT

   最开始打算用semaphore实现,

sem_t waitNonEmpty;
int empty=0;
sem_init(&waitNonEmpty, 1, empty); /*初始化信号量*/

sem_wait(&waitNonEmpty);             /*是否有"非空资源"*/
sem_post(&waitNonEmpty);              /*生成一个"非满资源"*/
sem_destroy(&waitNonEmpty);

后来在fc3 redhat7.3下man了sem_init, 第二个参数int pshared
The pshared
       argument indicates whether the semaphore is local to the current pro-
       cess ( pshared is zero) or is to be shared between several processes (
       pshared is not zero). LinuxThreads currently does not support process-
       shared semaphores, thus sem_init always returns with error ENOSYS if
       pshared is not zero.

最邪恶的现状出来了, 这俩系统没有实现sem的进程间通信, 如果设置not zero, 会返回ENOSYS的错误...
后来找了个redhat Enterprise 4 看了下文档, 貌似又支持了....

做个记号. 一会儿看看flock
fcntl 是唯一符合posix的文件锁

结构体flock的指针：

struct flcok {
short int l_type; /* 锁定的状态*/

//这三个参数用于分段对文件加锁，若对整个文件加锁，则：l_whence=SEEK_SET,l_start=0,l_len=0;
short int l_whence;/*决定l_start位置*/
off_t l_start; /*锁定区域的开头位置*/
off_t l_len; /*锁定区域的大小*/

pid_t l_pid; /*锁定动作的进程*/
};

l_type 有三种状态:
F_RDLCK 建立一个供读取用的锁定
F_WRLCK 建立一个供写入用的锁定
F_UNLCK 删除之前建立的锁定

int fcntl(int fd, int cmd, struct flock *lock);
int cmd
//F_SETLKW对加锁操作进行阻塞，
//F_SETLK不对加锁操作进行阻塞，立即返回

    当使用F_SETLK宏，不进行阻塞加锁操作时。两个进程有对文件加锁失败的情况出现。
    当使用F_SETLKW宏，进行阻塞加锁操作时。两个进程没有文件加锁失败的情况。但是根据进程的输出日志，可以明显看出A进程对文件操作时，B进程停止对文件操作。
    测试过程中打开文件使用O_RDWR | O_CREAT | O_APPEND模式，并对文件加写锁。锁对打开文件没有影响，但是对另一进程加锁和写操作有影响。
加锁对同一进程中的多线程无效。同一进程中的多线程对同一文件加锁，后加锁的线程会覆盖前一个线程加的文件锁。
fcntl文档中写到，一个进程对一个文件的区域只能加一个类型的锁

实现代码如下:
//filelock.h
#ifndef __FILE_LOCK_HPP__
#define __FILE_LOCK_HPP__

#ifdef __cplusplus
extern "C" {
#endif

int file_lock(int fd);
int file_unlock(int fd);

#ifdef __cplusplus
}
#endif

#endif //__FILE_LOCK_HPP__

------------------------华丽分割线-----------------------------
//filelock.cpp

#include
#include

#include "filelock.h";

int file_lock(int fd){
struct flock s_flock;
s_flock.l_type = F_WRLCK;

s_flock.l_whence = SEEK_SET;
s_flock.l_start = 0;
s_flock.l_len = 0;
s_flock.l_pid = getpid();

//F_SETLKW对加锁操作进行阻塞，
//F_SETLK不对加锁操作进行阻塞，立即返回
return fcntl(fd, F_SETLKW, &s_flock);
}

int file_unlock(int fd){
return fcntl(fd, F_SETLKW, F_UNLCK);
}

---------------------------------华丽的分割线--------------------------
test.cpp

#include "filelock.h"

#include
#include
#include

#include
#include
#include
#include
#include

int main(int argc,char *argv[]) {
int pid = -1;

int i = 5;
while(i--){
    if ((pid = fork()) < 0) { //fork出错
      puts("fork1 error");
    } else if (pid > 0) {//父进程
      sleep(5);

      if (waitpid(pid, NULL, 0) < 0)
        puts("waitpid error");

    } else {//子进程
      sleep(1);
      int li_file = 0;
      int li_lck_st = -1;
      li_file = open("tt.txt", O_WRONLY|O_CREAT, 0777);
      if( li_file < 0 ) {
        printf("file open error\n");
      }
      printf("li_file=[%d] pid=[%d]\n", li_file , getpid() );
      li_lck_st = file_lock(li_file);
      sleep(5);
      printf("li_lck_st=%d pid =%d\n", li_lck_st, getpid() );
      file_unlock(li_file);
      close(li_file);
      printf("close file pid=%d unlock\n", getpid());
      return 0;
    }
}
return 0;
}

------------------------------华丽分割线---------------------------
//makefile

#########################################################
#Project: test
#By: Khan.Lau
#Description: test
#########################################################

CC = gcc
CXX = g++
STRIP = strip
AR = ar

PROJ = $(shell pwd)
DLLPATH = $(shell find $(PROJ) -name *.so*)

LIBPATH = /usr

INCS = -I$(LIBPATH)/include \
    -I$(PROJ)/src/inc \
    -I$(PROJ)/src

CXXINCS = -I$(LIBPATH)/include \
    -I$(LIBPATH)/include/c++/4.3 \
    -I$(LIBPATH)/include/c++/4.3/backward \
    -I$(PROJ)/src/inc \
    -I$(PROJ)/src

CFLAGS = -g -Wall $(CXXINCS)
#
CONFIGURATION = release
#
BIN = test.exe
#LIB = lib/HuaWeiBsc.a

#包路径
LIBS = -L$(PROJ)/lib \
    -L$(LIBPATH)/lib -lz

SRCS = $(wildcard \
    src/lib/*.cpp \
    src/kernel/*.cpp)

OBJBINS = $(SRCS:.cpp=.o)

.c.o:
    $(CC) -o $@ -c $< $(CFLAGS)

.cpp.o:
    $(CXX) -o $@ -c $< $(CFLAGS)

COLORH=echo -en "\033[1;32;40m"
COLORN=echo -en "\033[m"

all : $(BIN)

$(BIN) : $(OBJBINS)
    $(CXX) -o $(CONFIGURATION)/$(BIN) $(OBJBINS) $(LIBS)
    @$(COLORN)     $(shell echo "$(BIN) build complete.")

#$(LIB) : $(OBJBINS)
#    ar rc $(LIB) $(OBJBINS)

clean :
    rm -f $(OBJBINS)
    rm -f $(BIN)

-----------------------------华丽分割线--------------------------
测试环境 ubuntu 8.10, redhat 7.3, redhat fc3 redhat enterprise 4.6
结果:
khan@khan-laptop:~/project/filelock/release$ ./test.exe
li_file=[3] pid=[10959]
li_lck_st=0 pid =10959
close file pid=10959 unlock
li_file=[3] pid=[10961]
li_lck_st=0 pid =10961
close file pid=10961 unlock
li_file=[3] pid=[10964]
li_lck_st=0 pid =10964
close file pid=10964 unlock
li_file=[3] pid=[10966]
li_lck_st=0 pid =10966
close file pid=10966 unlock
li_file=[3] pid=[10969]
li_lck_st=0 pid =10969
close file pid=10969 unlock

Khan's Notebook 2008-12-24 10:45 发表评论

linux /proc/文件系统.

Khan's Notebook — Fri, 24 Oct 2008 06:16:00 GMT

    最近要做一个jni给java来采集系统信息. 支持linux和windows
    采集的内容包括. 系统所有进程名, cpu占用率, 内存占用率, 系统内存大小, 已用内存大小, 可用内存大小, 分区大小, 已用分区磁盘空间, 可用分区磁盘空间. 系统信息. cpu核心总数..
    在windows下已经使用系统提供的api一一完成并经过调试. linux为了保证代码的统一. 也用了jni的方式

    linux下我老以为会有类似的api提供. 翻了半天google, 最终决定还是从/proc文件系统开始来.
不过/proc方式的好处就是不论哪种语言. 只要他有操作文件的能力. 都可以获得这些信息. 而不局限于c或者c++

    要点1. /proc不是物理文件系统. 他是对内存数据的映射, 是驱动留给开发者和使用者的接口, 所以不管你什么时候用ls指令也好, 用stat来读 st_size也好. 他的大小都是0字节.
    要点2. 由于是vfs, 不要试图往/proc中扔文件或者目录

    /proc目录中. 有不少信息. 我这次项目涉及到如下

    /proc/stat      //实时的系统信息, 我感兴趣的主要是cpu负载数据
    /proc/loadavg   //一段时间内 cpu负载的平均数以及最近一次的pid
    /proc/cpuinfo   //cpu信息频率核心支持特性
    /proc/version   //系统内核版本系统发行版本 gcc版本

    /proc目录下每个以数字命名的子目录都代表一个进程, 目录名则是他的pid
    /proc/(pid)/cmdline 该进程启动时的命令, 系统核心进程应该是空的
    /proc/(pid)/stat     里面记录着pid, 进程名(short_cmd)等等
    /proc/(pid)/environ 记录着系统执行的环境变量

其他的改天碰到再看吧.

Khan's Notebook 2008-10-24 14:16 发表评论

c语言（a ＜ b ＜ c ）的陷阱

Khan's Notebook — Thu, 23 Oct 2008 08:35:00 GMT

很久没有碰c/c++了, 近两年都是java为主, 偶尔用一下c/c++

(a(a
网友给我扔来了c99的标准
§6.5.9 第86页 89) The expression ameans (a
意思也就是说. (a1.( (a2.a3.所以, 最终表达式运算的是 (1
C语言中. 虽然任何不等于0的数为真. 但是实际在宏定义中 TRUE == 1 FALSE == 0;

Khan's Notebook 2008-10-23 16:35 发表评论

sourceforge又被封了...你们想让我说什么呢....

Khan's Notebook — Mon, 07 Jul 2008 15:28:00 GMT
   此贴是原创, 又不算技术, 关乎开源, 但是又无关软件...矛盾啊....
   半夜想down个mingw32... 去sourceforge.发现又上不去了. 凭直觉, 网站出问题的机会几乎没有. 开了个jondo, 果然能上去.
   上面的人又封sourceforge了.从06年LUPA事件到现在, 又开始了.
    开jondo down东西. 速度不足2k. tor速度更慢, 大家有没有什么好的工具. 这个时势没办法. 不能忍受就要学会享受.
    世道真是越来越乱了......

Khan's Notebook 2008-07-07 23:28 发表评论

VC6 与GCC-avr交叉环境配置

Khan's Notebook — Tue, 24 Jun 2008 04:05:00 GMT
01、在C:或其他盘下安装VC6.0
02、在C:或其他盘下新建ECC文件夹
03、在C:\ECC目录下安装WinAVR-20040720版
04、在C:\ECC目录下新建common文件夹
05、把lib和inc文件夹copy到C:\ECC\common目录下
06、把cl.exe; lhex.exe; link.exe; lview.exe; nmake.exe; rc.exe; sp.exe; ecc.reg; 这8个文件COPY到C:\ECC目录下
07、把EccAddin.pdb和EccAddin.dll 文件copy到VC目录下的\common\msdev98\addins 目录下
08、把GccWizard.awx 文件copy到 VC目录下的\common\msdev98\template 目录下
09、在任何目录下安装port95nt.exe
10、把avr5.x 文件copy到C:\ECC\Winavr\avr\lib\ldscripts 目录下
11、把usertype 文件copy到 VC目录下的\common\msdev98\bin 目录下
12、用记事本打开ecc.reg修改路径并保存，双击此文件添加到注册表中
13、打开VC++6.0; 在tools菜单->options->directories中将 C:\ECC\common\inc和C:\ECC\winavr\include 两个目录添加到include file选项中。同时将C:\ECC目录添加到executable files 选项中；并将之移到顶部。

SP.exe 烧录的配置自己google吧

备注:
07 把EccAddin.pdb和EccAddin.dll 文件copy到VC目录下的\common\msdev98\addins 目录下
这俩文件是自己写d

Khan's Notebook 2008-06-24 12:05 发表评论

GCC Mingw编译JNI dll要点

Khan's Notebook — Mon, 23 Jun 2008 04:57:00 GMT
本来想做一个win32平台下, 由于vc没有psapi.dll的库. 所以选择了mingw包和gcc编译器.

java部分
这里主要是申明接口. javah工具会根据你声明的接口自动生成对于的.h头文件

//SystemInfo.java
package com.khan.system;

public abstract class SystemInfo
{
    // public: ................................................................

    /**
    * A simple class to represent data snapshots taken by {@link #makeCPUUsageSnapshot}.
    */
public static final class CPUUsageSnapshot {
    public final long m_time, m_CPUTime;

      // constructor is private to ensure that makeCPUUsageSnapshot()
      // is used as the factory method for this class:
    private CPUUsageSnapshot (final long time, final long CPUTime) {
      m_time = time;
      m_CPUTime = CPUTime;
    }

} // end of nested class

    // Custom exception class for throwing
public static final class NegativeCPUTime extends Exception {}

    /**
    * Minimum time difference [in milliseconds] enforced for the inputs into
    * {@link #getProcessCPUUsage(SystemInfo.CPUUsageSnapshot,SystemInfo.CPUUsageSnapshot)}.
    * The motivation for this restriction is the fact that System.currentTimeMillis()
    * on some systems has a low resolution (e.g., 10ms on win32). The current value
    * is 100 ms.
    */
public static final int MIN_ELAPSED_TIME = 100;

    /**
    * Creates a CPU usage data snapshot by associating CPU time used with system
    * time. The resulting data can be fed into
    * {@link #getProcessCPUUsage(SystemInfo.CPUUsageSnapshot,SystemInfo.CPUUsageSnapshot)}.
    */
public static CPUUsageSnapshot makeCPUUsageSnapshot() throws SystemInfo.NegativeCPUTime {
    long prCPUTime = getProcessCPUTime ();
    if (prCPUTime<0)
      throw new NegativeCPUTime();
    return new CPUUsageSnapshot (System.currentTimeMillis (), getProcessCPUTime ());
}

    /**
    * Computes CPU usage (fraction of 1.0) between start.m_CPUTime and
    * end.m_CPUTime time points [1.0 corresponds to 100% utilization of
    * all processors].
    *
    * @throws IllegalArgumentException if start and end time points are less than
    * {@link #MIN_ELAPSED_TIME} ms apart.
    * @throws IllegalArgumentException if either argument is null;
    */
public static double getProcessCPUUsage (final CPUUsageSnapshot start, final CPUUsageSnapshot end) {
    if (start == null)
      throw new IllegalArgumentException ("null input: start");
    if (end == null)
      throw new IllegalArgumentException ("null input: end");
    if (end.m_time < start.m_time + MIN_ELAPSED_TIME)
      throw new IllegalArgumentException ("end time must be at least " + MIN_ELAPSED_TIME + " ms later than start time");

    return ((double)(end.m_CPUTime - start.m_CPUTime)) / (end.m_time - start.m_time);
}

    /**
    * Returns the PID of the current process. The result is useful when you need
    * to integrate a Java app with external tools.
    */
public static native int getProcessID ();

    /**
    * Returns the number of processors on machine
    */
public static native int getCPUs ();

    /**
    * Returns CPU (kernel + user) time used by the current process [in milliseconds].
    * The returned value is adjusted for the number of processors in the system.
    */
public static native long getProcessCPUTime ();

    /**
    * Returns CPU (kernel + user) time used by the current process [in perecents].
    * The returned value is either CPU percentage, or zero if this is not supported by OS.
    * Currently it is supported by Solaris8, and not supported by Windows XP
    */
public static native double getProcessCPUPercentage();

    /**
    * Returns maximum memory available in the system.
    */
public static native long getMaxMem ();

    /**
    * Returns current free memory in the system.
    */
public static native long getFreeMem ();

    /**
    * Returns system name info like "uname" command output
    */
public static native String getSysInfo ();

    /**
    * Returns CPU usage (fraction of 1.0) so far by the current process. This is a total
    * for all processors since the process creation time.
    */
public static native double getProcessCPUUsage ();

    /**
    * Returns current space allocated for the process, in Kbytes. Those pages may or may not be in memory.
    */
public static native long getMemoryUsage();

    /**
    * Returns current process space being resident in memory, in Kbytes.
    */
public static native long getMemoryResident();

    /**
    * Sets the system native process PID for which all measurements will be done.
    * If this method is not called then the current JVM pid will act as a default.
    * Returns the native-dependent error code, or 0 in case of success.
    */
public static native int setPid(int pid);

    /**
    * Closes native-dependent process handle, if necessary.
    */
public static native int detachProcess();

    // protected: .............................................................

    // package: ...............................................................

    // private: ...............................................................

private SystemInfo() {} // prevent subclassing

private static final String SILIB = "SystemInfo";

static {
    // loading a native lib in a static initializer ensures that it is
    // available done before any method in this class is called:
    try {
      System.loadLibrary (SILIB);
    }catch (UnsatisfiedLinkError e){
      System.out.println("native lib '" + SILIB
                         + "' not found in 'java.library.path': "
                         + System.getProperty ("java.library.path"));
    }catch (Exception e){
      System.out.println(e.getMessage());
    }
}

} // end of class

//AppMain.java 测试文件
package com.khan.system;

public class AppMain {
    /**
     * Default constructor
     */
    public AppMain() {
        // TODO: Add constructor code here
    }

    public static void main(String[] args) {
      try {
        Thread.sleep(1000);
        System.out.println("getMaxMem:" + SystemInfo.getMaxMem());
        System.out.println("getCPUs:" + SystemInfo.getCPUs());
        System.out.println("getSysInfo:" + SystemInfo.getSysInfo());
      }catch (Exception e){
        System.out.println(e.getMessage());
      }
    }

}

java部分工程文件. 等同与makefile
ant build.xml

    simple example build file





































在工程目录下ant 编译工程
build目录为本工程目标二进制文件目录. 编译后的class在此目录下
然后到build目录下
javah javah -jni com.khan.system.SystemInfo //注意, 一定要使用包全路径. 如果不是default包的话.
会在此目录下生成3个.h文件
com_khan_system_SystemInfo.h
com_khan_system_SystemInfo_CPUUsageSnapshot.h
com_khan_system_SystemInfo_NegativeCPUTime.h

java这边的准备工作完成

接下来处理c部分
新建一个c工程. 我用gcc的. 所以这些部分我手工完成的
将刚刚的.h文件实现

/* ------------------------------------------------------------------------- */
/*
* An implementation of JNI methods in com.vladium.utils.SystemInformation
* class. The author compiled it using Microsoft Visual C++ and GCC for Win32 but the code
* should be easy to use with any compiler for win32 platform.
*
* For simplicity, this implementaion assumes JNI 1.2+ and omits error handling.
*
* Enhanced by Peter V. Mikhalenko (C) 2004, Deutsche Bank [peter@mikhalenko.com]
* Original source (C) 2002, Vladimir Roubtsov [vlad@trilogy.com]
*/
/* ------------------------------------------------------------------------- */

#include
#include
#include
#include
#include
#include

#include "include/com_khan_system_SystemInfo.h"

static jint s_PID;
static HANDLE s_currentProcess;
static int alreadyDetached;
static int s_numberOfProcessors;
static SYSTEM_INFO systemInfo;
static WORD processorArchitecture;
static DWORD pageSize;
static DWORD processorType;
static WORD processorLevel;
static WORD processorRevision;

#define INFO_BUFFER_SIZE 32768
#define BUFSIZE 2048

//BOOL flll = TRUE;
/* ------------------------------------------------------------------------- */

/*
* A helper function for converting FILETIME to a LONGLONG [safe from memory
* alignment point of view].
*/
static LONGLONG fileTimeToInt64 (const FILETIME * time)
{
    ULARGE_INTEGER _time;

    _time.LowPart = time->dwLowDateTime;
    _time.HighPart = time->dwHighDateTime;

    return _time.QuadPart;
}
/* ......................................................................... */

/*
* This method was added in JNI 1.2. It is executed once before any other
* methods are called and is ostensibly for negotiating JNI spec versions, but
* can also be conveniently used for initializing variables that will not
* change throughout the lifetime of this process.
*/
JNIEXPORT jint JNICALL JNI_OnLoad (JavaVM * vm, void * reserved)
{
s_PID = _getpid ();
s_currentProcess = GetCurrentProcess ();
//externalCPUmon = 0;
alreadyDetached = 0;

GetSystemInfo (&systemInfo);
s_numberOfProcessors = systemInfo.dwNumberOfProcessors;
processorArchitecture = systemInfo.wProcessorArchitecture;
pageSize = systemInfo.dwPageSize;
processorType = systemInfo.dwProcessorType;
processorLevel = systemInfo.wProcessorLevel;
processorRevision = systemInfo.wProcessorRevision;
printf("SystemInfo.dll is Loaded");
return JNI_VERSION_1_2;
}
/* ......................................................................... */

JNIEXPORT void JNICALL
JNI_OnUnload (JavaVM * vm, void * reserved)
{
if (!alreadyDetached && s_currentProcess!=NULL) {
    CloseHandle(s_currentProcess);
    printf("[JNI Unload] Detached from native process.");
    fflush(stdout);
}
printf("SystemInfo.dll is UnLoaded");
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getCPUs
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_khan_system_SystemInfo_getCPUs(JNIEnv * env, jclass cls)
{
    return (jint)s_numberOfProcessors;
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getProcessID
* Signature: ()I
*/
JNIEXPORT jint JNICALL
Java_com_khan_system_SystemInfo_getProcessID(JNIEnv * env, jclass cls)
{
    return s_PID;
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    setPid
* Signature: ()I
*/
JNIEXPORT jint JNICALL
Java_com_khan_system_SystemInfo_setPid(JNIEnv * env, jclass cls, jint pid)
{
    DWORD errCode;
    LPVOID lpMsgBuf;
    s_PID = pid;
    s_currentProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE,pid);
    if (s_currentProcess==NULL) {
     errCode = GetLastError();
     FormatMessage(
              FORMAT_MESSAGE_ALLOCATE_BUFFER |
              FORMAT_MESSAGE_FROM_SYSTEM,
              NULL,
              errCode,
              MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
              (LPTSTR) &lpMsgBuf,
              0, NULL );

     printf("[CPUmon] Could not attach to native process. Error code: %ld Error description: %s", errCode, (char *)lpMsgBuf);
     fflush(stdout);
     LocalFree(lpMsgBuf);
     return errCode;
    }
    printf("[CPUmon] Attached to native process.");
    fflush(stdout);
    return 0;
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    detachProcess
* Signature: ()I
*/
JNIEXPORT jint JNICALL
Java_com_khan_system_SystemInfo_detachProcess(JNIEnv * env, jclass cls)
{
    if (!alreadyDetached && s_currentProcess!=NULL) {
     CloseHandle(s_currentProcess);
     alreadyDetached = 1;
     printf("[CPUmon] Detached from native process.");
     fflush(stdout);
    }
    return 0;
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getProcessCPUTime
* Signature: ()J
*/
JNIEXPORT jlong JNICALL
Java_com_khan_system_SystemInfo_getProcessCPUTime (JNIEnv * env, jclass cls)
{
    FILETIME creationTime, exitTime, kernelTime, userTime;
    DWORD errCode;
    LPVOID lpMsgBuf;

    BOOL resultSuccessful = GetProcessTimes (s_currentProcess, & creationTime, & exitTime, & kernelTime, & userTime);
    if (!resultSuccessful) {
     errCode = GetLastError();
     FormatMessage(
              FORMAT_MESSAGE_ALLOCATE_BUFFER |
              FORMAT_MESSAGE_FROM_SYSTEM,
              NULL,
              errCode,
              MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
              (LPTSTR) &lpMsgBuf,
              0, NULL );

     printf("[CPUmon] An error occured while trying to get CPU time. Error code: %ld Error description: %s", errCode, (char *)lpMsgBuf);

     fflush(stdout);
     LocalFree(lpMsgBuf);
     return -1;
    }

    return (jlong) ((fileTimeToInt64 (& kernelTime) + fileTimeToInt64 (& userTime)) /
        (s_numberOfProcessors * 10000));
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getMaxMem
* Signature: ()J
*/
JNIEXPORT jlong JNICALL
Java_com_khan_system_SystemInfo_getMaxMem(JNIEnv * env, jclass cls)
{
MEMORYSTATUS stat;
GlobalMemoryStatus (&stat);
        return (jlong)(stat.dwTotalPhys/1024);
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getFreeMem
* Signature: ()J
*/
JNIEXPORT jlong JNICALL
Java_com_khan_system_SystemInfo_getFreeMem (JNIEnv * env, jclass cls)
{
        MEMORYSTATUS stat;
GlobalMemoryStatus (&stat);
        return (jlong)(stat.dwAvailPhys/1024);
}
/* ......................................................................... */

/* define min elapsed time (in units of 10E-7 sec): */
#define MIN_ELAPSED_TIME (10000)

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getProcessCPUUsage
* Signature: ()D
*/
JNIEXPORT jdouble JNICALL
Java_com_khan_system_SystemInfo_getProcessCPUUsage(JNIEnv * env, jclass cls)
{
    FILETIME creationTime, exitTime, kernelTime, userTime, nowTime;
    LONGLONG elapsedTime;
    DWORD errCode;
    LPVOID lpMsgBuf;

    BOOL resultSuccessful = GetProcessTimes (s_currentProcess, & creationTime, & exitTime, & kernelTime, & userTime);
    if (!resultSuccessful) {
     errCode = GetLastError();
     FormatMessage(
              FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
              NULL,
              errCode,
              MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
              (LPTSTR) &lpMsgBuf,
              0, NULL );

     printf("[CPUmon] An error occured while trying to get CPU time. Error code: %ld Error description: %s", errCode, (char *)lpMsgBuf);
     fflush(stdout);
     LocalFree(lpMsgBuf);
     return -1.0;
    }
    GetSystemTimeAsFileTime (& nowTime);

    /*
        NOTE: win32 system time is not very precise [~10ms resolution], use
        sufficiently long sampling intervals if you make use of this method.
    */

    elapsedTime = fileTimeToInt64 (& nowTime) - fileTimeToInt64 (& creationTime);

    if (elapsedTime < MIN_ELAPSED_TIME)
        return 0.0;
    else
        return ((jdouble) (fileTimeToInt64 (& kernelTime) + fileTimeToInt64 (& userTime))) /
            (s_numberOfProcessors * elapsedTime);
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getProcessCPUPercentage
* Signature: ()D
*/
JNIEXPORT jdouble JNICALL
Java_com_khan_system_SystemInfo_getProcessCPUPercentage (JNIEnv * env, jclass cls)
{
// Not implemented on Windows
        return (jdouble)(-1.0);
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getMemoryUsage
* Signature: ()J
*/
JNIEXPORT jlong JNICALL
Java_com_khan_system_SystemInfo_getMemoryUsage (JNIEnv * env, jclass cls)
{
    PROCESS_MEMORY_COUNTERS pmc;

    if ( GetProcessMemoryInfo( s_currentProcess, &pmc, sizeof(pmc)) )
    {
return (jlong)(pmc.PagefileUsage/1024);
    } else {
return (jlong)(0);
    }
}
/* ......................................................................... */

/*
* Class:     com_vladium_utils_SystemInformation
* Method: getMemoryResident * Signature: ()J
*/
JNIEXPORT jlong JNICALL
Java_com_khan_system_SystemInfo_getMemoryResident(JNIEnv * env, jclass cls)
{
    PROCESS_MEMORY_COUNTERS pmc;

    if ( GetProcessMemoryInfo( s_currentProcess, &pmc, sizeof(pmc)) )
    {
        return (jlong)(pmc.WorkingSetSize/1024);
    } else {
         return (jlong)(0);
    }
}

/*
* Class:     com_vladium_utils_SystemInformation
* Method:    getSysInfo
* Signature: ()S
*/
JNIEXPORT jstring JNICALL
Java_com_khan_system_SystemInfo_getSysInfo(JNIEnv * env, jclass cls)
{
char buf[2048];
char buf2[512];
jstring retval;
OSVERSIONINFOEX osvi;
BOOL bOsVersionInfoEx;
TCHAR infoBuf[INFO_BUFFER_SIZE];

DWORD bufCharCount = INFO_BUFFER_SIZE;
*buf = 0; //c语言. 变量定义所有代码在前
*buf2 = 0;
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
{
    osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
    if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) ) {
      // Return empty string in case of problems
      goto next_label;
    }
}

switch (osvi.dwPlatformId)
{
    // Test for the Windows NT product family.
    case VER_PLATFORM_WIN32_NT:

      // Test for the specific product.
      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2 )
        strcat(buf,"WinServer2003, ");

      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1 )
        strcat(buf,"WinXP ");

      if ( osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0 )
        strcat(buf,"Win2K ");

      if ( osvi.dwMajorVersion <= 4 )
        strcat(buf,"WinNT ");

      // Display service pack (if any) and build number.

      if( osvi.dwMajorVersion == 4 && lstrcmpi( osvi.szCSDVersion, "Service Pack 6" ) == 0 )
      {
        HKEY hKey;
        LONG lRet;

        // Test for SP6 versus SP6a.
        lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE, "SOFTWAREMicrosoftWindows NTCurrentVersionHotfixQ246009", 0, KEY_QUERY_VALUE, &hKey );
        if( lRet == ERROR_SUCCESS ) {
          sprintf(buf2, "SP 6a (Build %d), ", (int)(osvi.dwBuildNumber & 0xFFFF) );
          strcat(buf,buf2);
        }
        else // Windows NT 4.0 prior to SP6a
        {
          sprintf(buf2, "%s (Build %d), ",
          osvi.szCSDVersion,
          (int)(osvi.dwBuildNumber & 0xFFFF));
          strcat(buf,buf2);
        }

        RegCloseKey( hKey );
      }
      else // not Windows NT 4.0
      {
        sprintf(buf2, "%s (Build %d), ", osvi.szCSDVersion, (int)(osvi.dwBuildNumber & 0xFFFF));
        strcat(buf,buf2);
      }
      break;

      // Test for the Windows Me/98/95.
    case VER_PLATFORM_WIN32_WINDOWS:
      if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
      {
        strcat(buf,"Win95 ");
        if ( osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B' )
          strcat(buf,"OSR2 " );
      }

      if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
      {
        strcat(buf,"Win98 ");
        if ( osvi.szCSDVersion[1] == 'A' )
          strcat(buf,"SE " );
      }

      if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
      {
        strcat(buf,"WinME ");
      }
      break;

    case VER_PLATFORM_WIN32s:
      strcat(buf,"Win32s ");
      break;
}

next_label:

strcat(buf,"on ");
// Get and display the name of the computer.
bufCharCount = INFO_BUFFER_SIZE;
if( !GetComputerName( infoBuf, &bufCharCount ) )
    goto next_label_2;
strcat(buf, infoBuf );

next_label_2:
strcat(buf," (");
if (!(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS && osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)) {
    // Win95 does not keep CPU info in registry
    LONG lRet;
    HKEY hKey;
    char szOrigCPUType[BUFSIZE];
    int i=0;
    DWORD dwBufLen=BUFSIZE;
    lRet = RegOpenKeyEx( HKEY_LOCAL_MACHINE, "HARDWAREDESCRIPTIONSystemCentralProcessor", 0, KEY_QUERY_VALUE, &hKey );
    if( lRet != ERROR_SUCCESS ) {
      goto next_label_3;
    }

    lRet = RegQueryValueEx( hKey, "ProcessorNameString", NULL, NULL, (LPBYTE) szOrigCPUType, &dwBufLen);
    if( (lRet != ERROR_SUCCESS) || (dwBufLen > BUFSIZE) ) {
      goto next_label_3;
    }
    RegCloseKey( hKey );

    if (strlen(szOrigCPUType)>0) {
      while(szOrigCPUType[i]==' ' && szOrigCPUType[i]!=0)
        i++;

      strcat(buf,szOrigCPUType+i);
    } else
      goto next_label_3;
} else {
next_label_3:
   if (processorArchitecture==PROCESSOR_ARCHITECTURE_UNKNOWN)
        strcat(buf,"unknown_arch");
   else if (processorArchitecture==PROCESSOR_ARCHITECTURE_INTEL) {
     strcat(buf,"Intel ");
     sprintf(buf2,"level %d ",processorLevel);
     strcat(buf,buf2);
   } else if (processorArchitecture==PROCESSOR_ARCHITECTURE_IA64)
        strcat(buf,"IA64 ");
   else if (processorArchitecture==PROCESSOR_ARCHITECTURE_MIPS)
        strcat(buf,"MIPS ");
   else if (processorArchitecture==PROCESSOR_ARCHITECTURE_ALPHA)
        strcat(buf,"Alpha ");
   else if (processorArchitecture==PROCESSOR_ARCHITECTURE_PPC)
        strcat(buf,"PowerPC ");
   else if (processorArchitecture==PROCESSOR_ARCHITECTURE_SHX)
        strcat(buf,"SHX ");
   else if (processorArchitecture==PROCESSOR_ARCHITECTURE_ALPHA64)
        strcat(buf,"Alpha64 ");
   else
        strcat(buf,"unknown_arch ");
}

strcat(buf,")");

retval = (*env)->NewStringUTF(env,buf);
return retval;
}
/* ......................................................................... */

#undef MIN_ELAPSED_TIME

/* ------------------------------------------------------------------------- */
/* end of file */

编写makefile
#    Project: SystemInfo
#    Makefile created by Khan.Lau
#    Write    by 2007-05-16

#    应用程序名
#LIB = SystemInfo.a
DLL =    SystemInfo.dll
#BIN = SystemInfo.exe

#    输出目录
#    CONFIGURATION = debug
CONFIGURATION    =    release

#    取得项目的当前工作路径
PROJECT_PATH = "D:/Project/Cplus/SystemInfo/src"

CPP = g++
CC = gcc
COMPILER = $(CC)

#    c/c++库路径
LIBPATH = "D:/Develop/CPlus/MinGW/lib"

WINDRES = windres.exe
RES =

#    包路径
LIBS = -L$(LIBPATH) \
    -lpsapi

INCS = -I$(LIBPATH)/include \
    -ID:/Develop/Java/jdk1.5.0_02/include \
    -ID:/Develop/Java/jdk1.5.0_02/include/win32 \
    -I$(PROJECT_PATH)

CXXINCS = -I$(LIBPATH)/include \
    -I$(LIBPATH)/include/c++/3.2.3 \
    -I$(LIBPATH)/include/c++/3.2.3/backward \
    -I$(LIBPATH)/include/c++/3.2.3/mingw32 \
    -I$(PROJECT_PATH)

DLLFLAGS = -DBUILD_DLL
CXXFLAGS = $(DLLFLAGS) -g -Wall $(CXXINCS)
CFLAGS = $(DLLFLAGS) -Wall $(INCS)

COMPILER_FLAG = $(CFLAGS)

RM = rm -f

LINKOBJ = $(CONFIGURATION)/SystemInfo.o    \
                $(RES)

.PHONY:    all all-before all-after clean clean-custom rebuild

all: all-before $(DLL) all-after

clean: clean-custom
    ${RM} $(LINKOBJ) $(CONFIGURATION)/$(DLL)

$(LIB): $(LINKOBJ)
    ar -r $(CONFIGURATION)/$(LIB) $(LINKOBJ)

$(DLL): $(LINKOBJ)
        $(COMPILER) -shared -Wl,--add-stdcall-alias -o $(CONFIGURATION)/$(DLL) $(LINKOBJ) $(LIBS)

$(BIN):    $(LINKOBJ)
    $(COMPILER) -o $(CONFIGURATION)/$(BIN) $(LINKOBJ) $(LIBS)

#缩减可执行文件大小
strip:
    strip    $(CONFIGURATION)/$(LIB)

################################################################################

$(CONFIGURATION)/SystemInfo.o: src/dll/SystemInfo.c
    $(COMPILER) -c src/dll/SystemInfo.c -o $(CONFIGURATION)/SystemInfo.o $(COMPILER_FLAG)

################################################################################

rebuild: clean    all

makefile中注意
$(DLL): $(LINKOBJ)
        $(COMPILER) -shared -Wl,--add-stdcall-alias -o $(CONFIGURATION)/$(DLL) $(LINKOBJ) $(LIBS)

-shared -Wl,--add-stdcall-alias 这3个参数是一定要的. 具体含义请参阅gcc帮助..
否则会出现如下异常:java.lang.UnsatisfiedLinkError
如果你确认自己的dll名没有错. loadlibrary的名字也没有填错. 那应该就要检查如上部分了

实际发布的时候. 不要使用调试版本. 也就是编译参数不能有-g

ok, 现在make出dll使用吧....

我本地测试的输出结果为 :

getMaxMem:506604
getCPUs:1
getSysInfo:WinXP Service Pack 2 (Build 2600), on A7648944D08843B (Intel level 15 )
SystemInfo.dll is Loaded

Khan's Notebook 2008-06-23 12:57 发表评论

ubuntu 下安装wine

Khan's Notebook — Fri, 23 May 2008 15:18:00 GMT
编译源码的方式就不写了，无非就是解决依赖关系， down一堆的包，然后make
简单粗暴的来......

1.安装
sudo apt-get install wine

2.初始化
winecfg //不要用root模式, 也就是不要用sudo

如果出现以下警告或者错误:
preloader: Warning: failed to reserve range 00000000-60000000
err:dosmem:setup_dos_mem Cannot use first megabyte for DOS address space, please report

解决方法: 其实我不清楚为什么要这么做....唉.....
sudo sysctl -w vm.mmap_min_addr=0

然后打开sysctl.conf
sudo gedit /etc/sysctl.conf

#vm.mmap_min_addr = 65536 //注释掉这行
vm.mmap_min_addr = 0 //改为这行

3、设置中文问题

   先把字体simsun.ttc（在你的windows的安装目录里的font文件夹里找，找不到可以从网上下到）复制到 /home/你的用户名/.wine/drive_c/windows/fonts 文件夹中，要显示隐藏文件夹按Ctrl+H

修改注册表，在命令行输入 gedit ~/.wine/system.reg

找到“[System\\CurrentControlSet\\Hardware Profiles\\Current\\Software\\Fonts]”，将其中的““LogPixels”=dword:00000060”改成 ““LogPixels”=dword:00000070“。

再找到”[Software\\Microsoft\\Windows NT\\CurrentVersion\\FontSubstitutes] xxxx“项，将其中的”MS Shell Dlg“相关的两项修改成如下内容（即更换字体为宋体）：

“MS Shell Dlg”=”SimSun”
“MS Shell Dlg 2″=”SimSun”

然后：gedit ~/.wine/drive_c/windows/win.ini

在其中加上（如果没有），有的话修改成如下

[Desktop]
menufontsize=13
messagefontsize=13
statusfontsize=13
IconTitleSize=13

现在中文显示应该正常了

Khan's Notebook 2008-05-23 23:18 发表评论

linux下执行java的脚本

Khan's Notebook — Tue, 06 May 2008 07:26:00 GMT

#!/bin/sh
# Filename : StockDispatch
# & nohub
# 思路: 遍历当前目录和$JAVA_HOME/lib下所有的jar文件, 加入-cp的环境变量然后执行入口类
SETCOLOR_BOLD="echo -en \\033[1;32m"
SETCOLOR_NORMAL="echo -en \\033[0;39m"

CLASSPATH=""
CURRDIR="$(pwd)"
LIBDIR="$CURRDIR /usr/local/jdk1.5.0_02/lib"
tmpFile=./11
pidFile=./${0}pid

# find all jar library from current dir and CLASSPATH
find $LIBDIR -name "*.jar">$tmpFile

# add jar library to CLASSPATH
I=0
while read line
do
        I=`expr $I + 1 `
        if [ $I -eq 1 ]
        then
                CLASSPATH="${line}"
        else
                CLASSPATH="${CLASSPATH}:${line}"
        fi
done< $tmpFile

rm $tmpFile

# run program
if [ "-$1" != "-" ]; then   # if parameter 1 is not null
  echo "java -cp .:${CLASSPATH}  com.khan.AppMain.UpdateCell2CBC $1 > updatecell2cbc.log"
#  java -cp .:${CLASSPATH} com.khan.AppMain.UpdateCell2CBC $1> updatecell2cbc.log
else
    echo "  usage: $0  CellListFile"
fi

Khan's Notebook 2008-05-06 15:26 发表评论

epoll简介(转载)

Khan's Notebook — Wed, 02 Apr 2008 03:58:00 GMT
     摘要: Epoll epoll_event epoll_wait epoll_ctl epoll_create  阅读全文

Khan's Notebook 2008-04-02 11:58 发表评论

Epoll模型

Khan's Notebook — Wed, 02 Apr 2008 03:37:00 GMT
Linux 2.6内核中提高网络I/O性能的新方法-epoll I/O多路复用技术在比较多的TCP网络服务器中有使用，即比较多的用到select函数。

1、为什么select落后
    首先，在Linux内核中，select所用到的FD_SET是有限的，即内核中有个参数__FD_SETSIZE定义了每个FD_SET的句柄个数，在我用的2.6.15-25-386内核中，该值是1024，搜索内核源代码得到：
include/linux/posix_types.h:
#define __FD_SETSIZE         1024
也就是说，如果想要同时检测1025个句柄的可读状态是不可能用select实现的。或者同时检测1025个句柄的可写状态也是不可能的。其次，内核中实现 select是用轮询方法，即每次检测都会遍历所有FD_SET中的句柄，显然，select函数执行时间与FD_SET中的句柄个数有一个比例关系，即 select要检测的句柄数越多就会越费时。当然，在前文中我并没有提及poll方法，事实上用select的朋友一定也试过poll，我个人觉得 select和poll大同小异，个人偏好于用select而已。

2、内核中提高I/O性能的新方法epoll
    epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll。要使用epoll只需要这三个系统调用：epoll_create(2)， epoll_ctl(2)， epoll_wait(2)。
当然，这不是2.6内核才有的，它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)

Linux2.6内核epoll介绍
    先介绍2本书《The Linux Networking Architecture--Design and Implementation of Network Protocols in the Linux Kernel》，以2.4内核讲解Linux TCP/IP实现，相当不错.作为一个现实世界中的实现，很多时候你必须作很多权衡，这时候参考一个久经考验的系统更有实际意义。举个例子,linux内核中sk_buff结构为了追求速度和安全，牺牲了部分内存，所以在发送TCP包的时候，无论应用层数据多大,sk_buff最小也有272的字节.其实对于socket应用层程序来说，另外一本书《UNIX Network Programming Volume 1》意义更大一点.2003年的时候，这本书出了最新的第3版本，不过主要还是修订第2版本。其中第6章《I/O Multiplexing》是最重要的。Stevens给出了网络IO的基本模型。在这里最重要的莫过于select模型和Asynchronous I/O模型.从理论上说，AIO似乎是最高效的，你的IO操作可以立即返回，然后等待os告诉你IO操作完成。但是一直以来，如何实现就没有一个完美的方案。最著名的windows完成端口实现的AIO,实际上也是内部用线程池实现的罢了，最后的结果是IO有个线程池，你应用也需要一个线程池...... 很多文档其实已经指出了这带来的线程context-switch带来的代价。在linux 平台上，关于网络AIO一直是改动最多的地方，2.4的年代就有很多AIO内核patch,最著名的应该算是SGI那个。但是一直到2.6内核发布，网络模块的AIO一直没有进入稳定内核版本(大部分都是使用用户线程模拟方法，在使用了NPTL的linux上面其实和windows的完成端口基本上差不多了)。2.6内核所支持的AIO特指磁盘的AIO---支持io_submit(),io_getevents()以及对Direct IO的支持(就是绕过VFS系统buffer直接写硬盘，对于流服务器在内存平稳性上有相当帮助)。
    所以，剩下的select模型基本上就是我们在linux上面的唯一选择，其实，如果加上no-block socket的配置，可以完成一个"伪"AIO的实现，只不过推动力在于你而不是os而已。不过传统的select/poll函数有着一些无法忍受的缺点，所以改进一直是2.4-2.5开发版本内核的任务，包括/dev/poll，realtime signal等等。最终，Davide Libenzi开发的epoll进入2.6内核成为正式的解决方案

3、epoll的优点
<1>支持一个进程打开大数目的socket描述符(FD)
    select 最不能忍受的是一个进程所打开的FD是有一定限制的，由FD_SETSIZE设置，默认值是2048。对于那些需要支持的上万连接数目的IM服务器来说显然太少了。这时候你一是可以选择修改这个宏然后重新编译内核，不过资料也同时指出这样会带来网络效率的下降，二是可以选择多进程的解决方案(传统的 Apache方案)，不过虽然linux上面创建进程的代价比较小，但仍旧是不可忽视的，加上进程间数据同步远比不上线程间同步的高效，所以也不是一种完美的方案。不过 epoll则没有这个限制，它所支持的FD上限是最大可以打开文件的数目，这个数字一般远大于2048,举个例子,在1GB内存的机器上大约是10万左右，具体数目可以cat /proc/sys/fs/file-max察看,一般来说这个数目和系统内存关系很大。

<2>IO效率不随FD数目增加而线性下降
    传统的select/poll另一个致命弱点就是当你拥有一个很大的socket集合，不过由于网络延时，任一时间只有部分的socket是"活跃"的，但是select/poll每次调用都会线性扫描全部的集合，导致效率呈现线性下降。但是epoll不存在这个问题，它只会对"活跃"的socket进行操作---这是因为在内核实现中epoll是根据每个fd上面的callback函数实现的。那么，只有"活跃"的socket才会主动的去调用 callback函数，其他idle状态socket则不会，在这点上，epoll实现了一个"伪"AIO，因为这时候推动力在os内核。在一些 benchmark中，如果所有的socket基本上都是活跃的---比如一个高速LAN环境，epoll并不比select/poll有什么效率，相反，如果过多使用epoll_ctl,效率相比还有稍微的下降。但是一旦使用idle connections模拟WAN环境,epoll的效率就远在select/poll之上了。

<3>使用mmap加速内核与用户空间的消息传递。
    这点实际上涉及到epoll的具体实现了。无论是select,poll还是epoll都需要内核把FD消息通知给用户空间，如何避免不必要的内存拷贝就很重要，在这点上，epoll是通过内核于用户空间mmap同一块内存实现的。而如果你想我一样从2.5内核就关注epoll的话，一定不会忘记手工 mmap这一步的。

<4>内核微调
    这一点其实不算epoll的优点了，而是整个linux平台的优点。也许你可以怀疑 linux平台，但是你无法回避linux平台赋予你微调内核的能力。比如，内核TCP/IP协议栈使用内存池管理sk_buff结构，那么可以在运行时期动态调整这个内存pool(skb_head_pool)的大小--- 通过echo XXXX>/proc/sys/net/core/hot_list_length完成。再比如listen函数的第2个参数(TCP完成3次握手的数据包队列长度)，也可以根据你平台内存大小动态调整。更甚至在一个数据包面数目巨大但同时每个数据包本身大小却很小的特殊系统上尝试最新的NAPI网卡驱动架构。

4、epoll的工作模式
    令人高兴的是，2.6内核的epoll比其2.5开发版本的/dev/epoll简洁了许多，所以，大部分情况下，强大的东西往往是简单的。唯一有点麻烦是epoll有2种工作方式:LT和ET。
LT(level triggered)是缺省的工作方式，并且同时支持block和no-block socket.在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的，所以，这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表．
    ET (edge-triggered)是高速工作方式，只支持no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了(比如，你在发送，接收或者接收请求，或者发送接收的数据少于一定量时导致了一个EWOULDBLOCK 错误）。但是请注意，如果一直不对这个fd作IO操作(从而导致它再次变成未就绪)，内核不会发送更多的通知(only once),不过在TCP协议中，ET模式的加速效用仍需要更多的benchmark确认。
    epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用，具体用法请参考http://www.xmailserver.org/linux-patches/nio-improve.html ，在http://www.kegel.com/rn/也有一个完整的例子，大家一看就知道如何使用了
Leader/follower模式线程pool实现，以及和epoll的配合。

5、 epoll的使用方法
    首先通过create_epoll(int maxfds)来创建一个epoll的句柄，其中maxfds为你epoll所支持的最大句柄数。这个函数会返回一个新的epoll句柄，之后的所有操作将通过这个句柄来进行操作。在用完之后，记得用close()来关闭这个创建出来的epoll句柄。之后在你的网络主循环里面，每一帧的调用epoll_wait(int epfd, epoll_event events, int max events, int timeout)来查询所有的网络接口，看哪一个可以读，哪一个可以写了。基本的语法为：
nfds = epoll_wait(kdpfd, events, maxevents, -1);
其中kdpfd为用epoll_create创建之后的句柄，events是一个epoll_event*的指针，当epoll_wait这个函数操作成功之后，epoll_events里面将储存所有的读写事件。max_events是当前需要监听的所有socket句柄数。最后一个timeout是 epoll_wait的超时，为0的时候表示马上返回，为-1的时候表示一直等下去，直到有事件范围，为任意正整数的时候表示等这么长的时间，如果一直没有事件，则范围。一般如果网络主循环是单独的线程的话，可以用-1来等，这样可以保证一些效率，如果是和主逻辑在同一个线程的话，则可以用0来保证主循环的效率。

epoll_wait范围之后应该是一个循环，遍利所有的事件：
for(n = 0; n < nfds; ++n) {
if(events[n].data.fd == listener) { //如果是主socket的事件的话，则表示有新连接进入了，进行新连接的处理。
    client = accept(listener, (struct sockaddr *) &local, &addrlen);
    if(client < 0){
      perror("accept");
      continue;
    }
    setnonblocking(client); // 将新连接置于非阻塞模式
    ev.events = EPOLLIN | EPOLLET; // 并且将新连接也加入EPOLL的监听队列。
                                   //注意，这里的参数EPOLLIN | EPOLLET并没有设置对写socket的监听，
                                   //如果有写操作的话，这个时候epoll是不会返回事件的，
                                   //如果要对写操作也监听的话，应该是EPOLLIN | EPOLLOUT | EPOLLET
    ev.data.fd = client;
    if (epoll_ctl(kdpfd, EPOLL_CTL_ADD, client, &ev) < 0) { // 设置好event之后，将这个新的event通过epoll_ctl
                                                             //加入到epoll的监听队列里面，这里用EPOLL_CTL_ADD
                                                             //来加一个新的 epoll事件，通过EPOLL_CTL_DEL来减少
                                                             //一个epoll事件，通过EPOLL_CTL_MOD来改变一个事件的
                                                             //监听方式。
      fprintf(stderr, "epoll set insertion error: fd=%d0, client);
      return -1;
    }
} else // 如果不是主socket的事件的话，则代表是一个用户socket的事件，

          //则来处理这个用户socket的事情，比如说read(fd,xxx)之类的，或者一些其他的处理。
    do_use_fd(events[n].data.fd);
}

对，epoll的操作就这么简单，总共不过4个API：epoll_create, epoll_ctl, epoll_wait和close。
如果您对epoll的效率还不太了解，请参考我之前关于网络游戏的网络编程等相关的文章。

    以前公司的服务器都是使用HTTP连接，但是这样的话，在手机目前的网络情况下不但显得速度较慢，而且不稳定。因此大家一致同意用 SOCKET来进行连接。虽然使用SOCKET之后，对于用户的费用可能会增加(由于是用了CMNET而非CMWAP)，但是，秉着用户体验至上的原则，相信大家还是能够接受的(希望那些玩家月末收到帐单不后能够保持克制...)。
这次的服务器设计中，最重要的一个突破，是使用了EPOLL模型，虽然对之也是一知半解，但是既然在各大PC网游中已经经过了如此严酷的考验，相信他不会让我们失望，使用后的结果，确实也是表现相当不错。在这里，我还是主要大致介绍一下这个模型的结构。
6、Linux下EPOll编程实例
EPOLL模型似乎只有一种格式，所以大家只要参考我下面的代码，就能够对EPOLL有所了解了，代码的解释都已经在注释中：

while (TRUE) {
int nfds = epoll_wait (m_epoll_fd, m_events, MAX_EVENTS, EPOLL_TIME_OUT);//等待EPOLL时间的发生，相当于监听，
                                                                             //至于相关的端口，需要在初始化EPOLL的时候绑定。
if (nfds <= 0)
    continue;
m_bOnTimeChecking = FALSE;
G_CurTime = time(NULL);
for (int i=0; i    try {
      if (m_events[i].data.fd == m_listen_http_fd)//如果新监测到一个HTTP用户连接到绑定的HTTP端口，
                                                  //建立新的连接。由于我们新采用了SOCKET连接，所以基本没用。
      {
        OnAcceptHttpEpoll ();
      } else if (m_events[i].data.fd == m_listen_sock_fd)//如果新监测到一个SOCKET用户连接到了绑定的SOCKET端口，
                                                        //建立新的连接。
      {
        OnAcceptSockEpoll ();
      } else if (m_events[i].events & EPOLLIN)//如果是已经连接的用户，并且收到数据，那么进行读入。
      {
        OnReadEpoll (i);
      }

      OnWriteEpoll (i);//查看当前的活动连接是否有需要写出的数据。
    } catch (int) {
      PRINTF ("CATCH捕获错误\n");
      continue;
    }
}
m_bOnTimeChecking = TRUE;
OnTimer ();//进行一些定时的操作，主要就是删除一些短线用户等。
}
　其实EPOLL的精华，也就是上述的几段短短的代码，看来时代真的不同了，以前如何接受大量用户连接的问题，现在却被如此轻松的搞定，真是让人不得不感叹，对哪。

Epoll模型主要负责对大量并发用户的请求进行及时处理，完成服务器与客户端的数据交互。其具体的实现步骤如下：
(a) 使用epoll_create()函数创建文件描述，设定将可管理的最大socket描述符数目。
(b) 创建与epoll关联的接收线程，应用程序可以创建多个接收线程来处理epoll上的读通知事件，线程的数量依赖于程序的具体需要。
(c) 创建一个侦听socket描述符ListenSock；将该描述符设定为非阻塞模式，调用Listen（）函数在套接字上侦听有无新的连接请求，在epoll_event结构中设置要处理的事件类型EPOLLIN，工作方式为 epoll_ET，以提高工作效率，同时使用epoll_ctl()注册事件，最后启动网络监视线程。
(d) 网络监视线程启动循环，epoll_wait()等待epoll事件发生。
(e) 如果epoll事件表明有新的连接请求，则调用accept（）函数，将用户socket描述符添加到epoll_data联合体，同时设定该描述符为非阻塞，并在epoll_event结构中设置要处理的事件类型为读和写，工作方式为epoll_ET.
(f) 如果epoll事件表明socket描述符上有数据可读，则将该socket描述符加入可读队列，通知接收线程读入数据，并将接收到的数据放入到接收数据的链表中，经逻辑处理后，将反馈的数据包放入到发送数据链表中，等待由发送线程发送。

Khan's Notebook 2008-04-02 11:37 发表评论