BlogJava-[NKU]sweet ＠ ICPC || TopCoder ||Other-随笔分类-学习心得http://www.blogjava.net/sweetsc/category/50265.html执念，自从2004zh-cnThu, 26 Jan 2012 15:00:29 GMTThu, 26 Jan 2012 15:00:29 GMT60编译原理入门以及战大作业心得（2）汇编简易入门http://www.blogjava.net/sweetsc/archive/2012/01/26/368903.html[NKU]sweet[NKU]sweetThu, 26 Jan 2012 14:42:00 GMThttp://www.blogjava.net/sweetsc/archive/2012/01/26/368903.htmlhttp://www.blogjava.net/sweetsc/comments/368903.htmlhttp://www.blogjava.net/sweetsc/archive/2012/01/26/368903.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/368903.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/368903.html
应刁哥多年前的约稿，外加结合编译原理系列连载，整理一下上一篇文章，写一个简易的汇编教程……
尽管谬误，疏漏若干，但是本文的目的不在于培养学霸，而在于让不会汇编的人简单看看就能写出个基本能用的汇编程序……
在程序设计中，我们知道一项基本原理：语言越高级，一般来讲容易编写，形式简洁，可移植性强，效率低……
反过来，语言越低级，越难编写，代码越容易是又臭又长还看不懂，越难移植，但是效率会很高……
汇编就是比较低级的语言了，由于其不太好移植，汇编版本又多种多样
因此，本着活学活用，到时候不会就查手册的原则，本文不会太着重强调语法，语法以intel语法为主……
Chapter1：一些基本知识
首先，CPU有若干寄存器，在32位CPU中，形如eax，ebx，ecx，edx……64位CPU则为rax，rbx……
虽然寄存器这个名字很NB，其实它的本质上就是int，为了向下兼容的需要，一些老的程序，也有可能能在新型的CPU上运行（详见DOS老游戏，有的能玩，有的不能玩）
以64位举例：
64位寄存器rax，低32位是eax，eax低16位是ax，ax高8位叫ah，低8位叫al……
CPU只能直接对寄存器进行运算……因为电路结构就是那样的……因此，所有的操作，都需要经过寄存器
譬如赋值：A = 1，实际上是 AX = 1; A = AX; 譬如 A = A + B，应该是 AX = A; AX += B; A = AX; 这样
我是比较不求甚解的，99%功能（运算，判断，指针）等，使用eax，ebx，ecx，edx都能搞定……于是咱们也就不说别的了……
Chapter2：汇编的基本语法：
汇编语言大概分为四个段，其中比较需要记住的就是代码段和数据段……
用类似高级语言的思路来讲，数据段用于定义一些全局变量，代码段用于写程序……
来看一个简单的 Hello World（环境：yasm，64位）
global main 
extern printf 
section .data 
ctrlout   db      '%s', 10, 0 
hw    db      'Hello World', 0 
; this is a comment
section .text
main:
mov rax, 0
mov rdi, ctrlout
mov rsi, hw
call printf
        mov rax, 0
ret
其中，刚开始global main 表示程序入口，由于这里直接调用了Linux的函数printf，之后需要gcc编译，所以叫做main，如果只使用中断输出的话，可以搞成_start
之后extern意义和C++类似，表示这个函数在别处，叫编译器以为他有就行……
section .data  表示数据段，后面是一些定义，以及初始化
注意这里定义的东西类型都像是指针一样，ctrlout，hw 实际上是地址……
初始化必须搞的干净一点，有一次调了半天不对，就是因为一个64位int，前4位没有初始化成0……
之后 section .text 表示代码段，这里调用C语言函数，网上说，64位汇编中，参数传递方式有了修改，大概是有4~5个寄存器专门保存参数，如果参数过多，再放入栈，rax存放栈中的参数个数……我们想printf("%s","Hello World")，就要调用两个参数，于是，我们把第一个参数，字符串ctrlout的指针mov进rdi，hw mov进rsi，rax赋值为0 ，然后，调用……
（实现时，需要手册自行查阅一下本机怎么搞）
函数的返回值在rax，于是return 0
然后 yasm -f elf64 XXX.asm
gcc -o XXX XXX.o
./XXX
一个崭新的hello world 出现了……
Chapter3：汇编的一些简单指令：
由于这是速成教程，选取一部分指令……要记住，CPU只能直接对寄存器进行运算……
mov：相当于赋值， mov eax，b  相当于eax = b；
注意：mov 后面的两个东西至少要有一个是寄存器……
同时，和高级语言一样，不能搞什么 mov 10，eax……
add：add eax，b 相当于eax+=b
sub：基本同上……
mul || imul：前面是无符号的乘，后面是有符号的乘，默认被乘数在AX，于是指令形如：mul BX，如果有溢出，则高位溢出到DX，记得备份DX的东西……
div  ||  idiv：前面是无符号整除，后面是有符号整除，默认被除数是DX（高16位）和AX（低16位），因此，除法之前记得把DX清零，否则数会不对……
之后商在AX，余数在DX
指令形如：div BX
push/pop：每个程序都有栈，或者是在程序中定义堆栈段，或者使用默认栈
push eax，表示把eax放进栈里，pop ebx，表示取出栈顶，放在ebx中……
push和pop异常重要，一个重要作用就是保护寄存器，譬如DX中有内容，但是现在要做乘法，没准会破坏DX（见上），于是，先PUSH DX，然后，乘法，然后POP DX，又好比你要调用一个函数，但是寄存器里有有用的信息，不保证这个函数不会破坏，于是，把所有寄存器先push进去，运行函数，然后再pop出来，这是常用技巧……
另外也可以用来给函数传参数，传时倒序压入，用时顺序取出，栈，先进后出，你们懂的……
Chapter4：if以及循环
首先我们要记得，被Dijkstra老爷子骂的一文不值的goto……
jmp语法和C++里的goto基本一样
start：
XXX
jmp start
然后，汇编没有if then，但是有条件goto
有个语句叫做cmp
cmp X，Y （老原则，这两个得有一个寄存器……如果和常数比较，常数必须在后面）
传说中具体实现是减法……
这个的效果是可能改变若干标识位的值……譬如：0标识，进位标识，溢出标识……等等……
然后，有若干指令
jl XX（l==less） 相当于 if (x<y) goto XX; 下同
jg XX（g==greater）
jle XX（ne==less or equal）
jge XX（ge==greter or equal）
jnle XX（n==no->nle==g）
jnge XX（n==no->nge==l）
有了if then，各种运算，我们就能做出来&&,||的逻辑
有了if then，我们也能做出循环……
很多的功能就有了……
Chapter5：实战
看看
int main() {
    int a,b,c;
    input(a);
    input(b);
    if (a < b) {
        c = a;
    } else {
        c = b;
    }
    print(c);
}
用汇编翻译出来啥样：
global main 
extern printf 
extern scanf 
section .data 
ctrlout   db      '%lld', 10, 0 
ctrlin    db      '%lld', 0 
_a db 0,0,0,0,0,0,0,0
_b db 0,0,0,0,0,0,0,0
_c db 0,0,0,0,0,0,0,0
section .text
main:
mov rax, 0
mov rdi, ctrlin
mov rsi, _a
call scanf
mov rax, 0
mov rdi, ctrlin
mov rsi, _b
call scanf
MOV rax, [_a]
CMP rax, [_b]
jl @0
jmp @2
@0:
MOV rax, [_a]
MOV [_c], rax
jmp @1
@2:
MOV rax, [_b]
MOV [_c], rax
@1:
mov rax, 0
mov rdi, ctrlout
mov rsi, [_c]
call printf
mov rax, 0
ret
Chapter6：其它
由于现实生活中，我需要写汇编时候实在是少，因此也没啥经验……尽管借助手册，可以对付着写一点汇编代码，但是那是不科学的……对我来讲，汇编告诉我们的一些底层的东西更有价值，可以在高级语言中有所体现：譬如一些表达式的写法，可以考虑写的更科学一些，譬如 c = a / b, q = a % b，记得写成 c = a / b; q = a - c * b，譬如灵活使用switch，等等……


[NKU]sweet 2012-01-26 22:42 发表评论
]]>编译原理入门以及战大作业心得（1）lex简易入门http://www.blogjava.net/sweetsc/archive/2012/01/16/368587.html[NKU]sweet[NKU]sweetMon, 16 Jan 2012 05:20:00 GMThttp://www.blogjava.net/sweetsc/archive/2012/01/16/368587.htmlhttp://www.blogjava.net/sweetsc/comments/368587.htmlhttp://www.blogjava.net/sweetsc/archive/2012/01/16/368587.html#Feedback1http://www.blogjava.net/sweetsc/comments/commentRss/368587.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/368587.html这里介绍一下今年的几大神大作业之编译原理……顺道在这里复习一下相关知识……
编译器的工作分成6步（王老师考试不厚道，这次考的居然不是这6步是啥……而是6步又分成哪两大部分……不表……），词法分析，语法分析，语义分析，中间代码生成，代码优化，代码生成……
词法分析顾名思义是认出词来……譬如关键字（if then else for int char等等），特殊符号（+-×/等等），标识符（变量名，函数名）等，以及可能返回一些错误，譬如有一些奇怪的不认识的东西混进来了（中国字，没定义的标点符号等等……），在处理标识符的时候，需要用一个符号表。因为标识符不能像关键字那样一概而论，要分清楚这是变量名，函数名，变量名的话还需要分清楚变量类型，int，char，double等，因此需要用符号表。所谓符号表，实际上数组就行了……
Unix提供了一个工具：lex，可以实现用正则表达式来实现词法分析……
这个东西版本多种多样，这里采用linux的flex，没有其它默认参数……这样默认生成的是C代码
下面提供一个简单例子：简单辨认出标识符，数字，以及其他……

 1 
 2 %{
 3 #include <stdio.h>
 4 int yywrap();
 5 %}
 6 
 7 D         [0-9]
 8 L         [a-zA-Z_]
 9 
10 %%
11 {D}+            { printf ("It is a digit ! \n"); }
12 {L}({L}|{D})*   { printf ("It is a ID! \n"); }
13 (.)*            { printf ("I don't know! \n"); }
14 %%
15 
16 int yywrap() { return 1; }
17 int main() {
18     yylex();
19     return 0;    
20 }
21 

前面的 %{ %} ，就是按照C语言的规范写一些头文件，常量，函数定义……
之后可以用正则表达式写一些自己的定义，譬如我这里定义了D表示数字，L表示字母
然后，两个 %% %% 中间，要写若干 正则表达式 { 干啥干啥 } 这样的格式，表示匹配上了这个，则做什么什么…… 这个会从上到下依次匹配……
最后，就是C函数了…… yywrap()貌似表示是否还有输入，一直return 1就行……
编译……首先，以上代码要存成 XX.l 的lex格式文件……
然后 lex XX.l ，会自动生成 lex.yy.c 文件……
gcc之即可……

［待续……］

[NKU]sweet 2012-01-16 13:20 发表评论
]]>数据库（作业？）入门指北http://www.blogjava.net/sweetsc/archive/2011/12/19/366664.html[NKU]sweet[NKU]sweetSun, 18 Dec 2011 16:00:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/12/19/366664.htmlhttp://www.blogjava.net/sweetsc/comments/366664.htmlhttp://www.blogjava.net/sweetsc/archive/2011/12/19/366664.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/366664.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/366664.html 因此这学期还是选了数据库……
于是近日在和大作业斗争……
大作业是大概要写一个能操作数据库的软件，并完成一些功能……
这个软件的话，用各种手段都可以，听说弟兄们有ASP的，有MFC的，有VB的……
古人教育我们，LAMP……又看到了ALP用过的一个神宝具，XAMPP……于是下载了XAMPP，打开虚拟机，一路next安装，之后运行xampp_ctrl，你们懂的

于是，输入http://127.0.0.1，出来网页了……
然后，修改几个地方……打开安装文件夹，网页都在那底下……把原来的index.php改成admin.php，然后自己写一个index.php：
1 <?php
2 echo "ASS WE CAN!!!";
3 ?>
恩……再输入http://127.0.0.1，奇迹出现了……
然后，咱们要解决一下IO问题……至少先画个输入框啥的出来……看看大概就懂了……采取post的方法，把输入的量都作为一个数组，传递给reg.php处理……
 1 <html>
 2 <body>
 3 
 4 <form method=post action="reg.php">
 5 姓名<input type=text name="name"><br>
 6 <input type=submit name=ok value="提交">
 7 </form>
 8 
 9 </body>
10 </html>
有图有真相：


然后，reg.php，连接数据库，并添加一条：

 1 <?php 
 2 
 3 #链接数据库，并检查是否成功，输出调试信息
 4 #php的变量名前需加$，无须声明就可使用
 5 
 6 $link=mysql_connect('localhost','root','');
 7 if(!$link) echo "连接数据库失败";
 8 
 9 #选择数据库
10 mysql_query("use test",$link);
11 
12 #生成命令，且输出调试信息……网页传来的信息，会存在_post数组中，按照下标调用即可
13 $ctrl = "insert into user(NAME) values('". $_POST["name"] . "')";
14 #echo ($ctrl); echo("</br>");
15 
16 #向用户表中插入一条新的记录，并输出提示
17 mysql_query($ctrl,$link);
18 
19 #调试信息……
20 $rs = MySQL_query("select * from user");
21 $cnt = MySQL_query("select count(*) from user");
22 $cnt = mysql_fetch_row($cnt);
23 $cnt = $cnt[0];
24 for ($i = 0; $i < $cnt; $i ++) {
25     print_r(mysql_fetch_row($rs));
26     echo("</br>");
27 }
28 
29 #关闭数据库链接
30 mysql_close($link);
31 
32 ?>
33 
34 <h1><a href="index.htm">回到首页</span></h1>

至此，物理学的大厦已经建成，作业差不多可以写了…………

[NKU]sweet 2011-12-19 00:00 发表评论
]]>工作笔记http://www.blogjava.net/sweetsc/archive/2011/12/08/365830.html[NKU]sweet[NKU]sweetWed, 07 Dec 2011 19:37:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/12/08/365830.htmlhttp://www.blogjava.net/sweetsc/comments/365830.htmlhttp://www.blogjava.net/sweetsc/archive/2011/12/08/365830.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/365830.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/365830.html感触很多，都午夜党了……想到哪里是哪里吧……

折腾了这么一通，任务初步完成了，也把Pthread大概会用了，收获也很大……
前半年，为了在ACM里面万一有点用，我开发了个java多线程模板……（实际技术含量不高）
本次接受到的任务，刚开始也是上java做的，但是java效率不高，大家都懂的……于是移植到C/C++，上pthread……
与之前的任务相比，这次可不是“等所有线程的case跑完，主线程输出答案”，那么轻松……java是个原生态支持多线程的语言，而且一个线程一个任务基本就没有冲突……我这个 =_= …… 多线程得访问一个公共的hash表…… 而且，这个表memory里面还装不下…… 外加C/C++有些东西，多个线程一起用，可能就挂了…… =_= …… 于是 =_= …… 总之好歹还是磕磕绊绊的搞出了个可行的方案……

程序设计语言太重要了……这是一切的根本……一个好的程序设计语言，或者说，更高一个层级来讲：工具，能够帮助你优雅的完成一些事情……譬如，了解了Matlab，或者Octave，Scilab之后，一些程序就能搞的很漂亮很写意……与高层次的东西相对的，C语言是根本。pthread、OS、编译，都是离不开的……尽管不见得要自己动手干，底层的东西也要知道……

本来计划10分钟写完，但是现在写的似乎有点多了……简单些吧……直奔计划篇
先把大作业刷了……把课都搞定了……
增强VIM，或转型EMACS，培养用这种强力编辑器管理工程的能力
多看看C语言，涉猎一下Octave，Ruby，python等等……
仔细想想今后干啥方向……
偶尔一刷题……

[NKU]sweet 2011-12-08 03:37 发表评论
]]>pthread学习笔记 IIIhttp://www.blogjava.net/sweetsc/archive/2011/12/04/365525.html[NKU]sweet[NKU]sweetSun, 04 Dec 2011 15:31:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/12/04/365525.htmlhttp://www.blogjava.net/sweetsc/comments/365525.htmlhttp://www.blogjava.net/sweetsc/archive/2011/12/04/365525.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/365525.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/365525.html 这个时候，我们需要使用条件变量
相关：
定义一个条件变量：
pthread_cond_t cook_finish;

相关函数：
pthread_cond_init(&cook_finish,NULL);
pthread_cond_destroy(&cook_finish);
初始化，老规矩，后面那个参数是属性
删除，老规矩……
pthread_cond_signal(&cook_finish);
让一个线程发出信号

pthread_cond_wait(&cook_finish,&lock); 
让一个线程坐等条件变量的信号……其中的lock还是那个互斥锁
为什么要用个锁呢……是为了避免一些悲剧情况的发生……

下面的代码有这么个问题：先是lock上，然后，坐等信号，然后解锁…… 其他的线程，也是lock上，发出信号，再解锁……
前文教育我们，互斥锁不能lock两次啊，这是为什么呢……经查询，坐等信号这个函数的实现，大致是：解锁 -> 坐等 -> 锁上继续……
所以，大丈夫，大丈夫……
以下代码构造了这么一个欢乐的场景：有个吃货，前来坐等吃东西，但是cooker需要工作3秒，才能产生出来食物……

  1 #include <pthread.h>
 2 #include <stdio.h>
 3 
 4 int tot = 0;
 5 pthread_mutex_t lock;
 6 pthread_cond_t cook_finish;
 7 
 8 struct node_t {
 9     int data;
10     struct node_t* next;
11 };
12 
13 typedef struct node_t node;
14 
15 void *eater(void *arg) {
16     printf("eater ready!!\n");
17     int * stat = (int*) arg;
18     int i;
19     pthread_mutex_lock(&lock);
20     printf("Waiting the cooker!!!\n");
21     pthread_cond_wait(&cook_finish,&lock);
22     pthread_mutex_unlock(&lock);
23     for (i = 0; i < *stat; i++) {
24         tot --;
25     }
26     printf("eater finish!!\n");
27     return NULL;
28 }
29 
30 void *food(void *arg) {
31     sleep(3);
32     printf("cooker ready!!\n");
33     int * stat = (int*) arg;
34     int i;
35     pthread_mutex_lock(&lock);
36     for (i = 0; i < *stat; i++) tot++;
37     pthread_mutex_unlock(&lock);
38     printf("cook finish!!\n");
39     pthread_cond_signal(&cook_finish);
40     return NULL;
41 }
42 
43 int main() {
44     node tmp = {123, NULL};
45     pthread_t thr[2];
46     void *exit_status;
47     pthread_mutex_init(&lock,NULL);
48     pthread_cond_init(&cook_finish,NULL);
49     int num = 1E8;
50     pthread_create(&thr[0], NULL, &eater, &num);
51     pthread_create(&thr[1], NULL, &food, &num);
52     pthread_join(thr[0],&exit_status);
53     pthread_join(thr[1],&exit_status);
54     printf("%d\n",tot);
55     pthread_mutex_destroy(&lock);
56     pthread_cond_destroy(&cook_finish);
57     return 0;
58 }
59 


[NKU]sweet 2011-12-04 23:31 发表评论
]]>pthread学习笔记 IIhttp://www.blogjava.net/sweetsc/archive/2011/12/03/365439.html[NKU]sweet[NKU]sweetFri, 02 Dec 2011 17:08:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/12/03/365439.htmlhttp://www.blogjava.net/sweetsc/comments/365439.htmlhttp://www.blogjava.net/sweetsc/archive/2011/12/03/365439.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/365439.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/365439.html来解决这样一个多线程共享数据的问题：譬如跑一个计数的程序，N个线程都在产生答案，然后解要存在一个int中……
如果不加处理，会有这么个Bug：现在内存里面数字是N，线程每次把它＋1的过程需要先读，把它复制到寄存器，＋1，再存回N去……
如果多线程的话，很可能是：线程1读取N，线程2读取N，线程1 N += 1，线程2 N += 1，线程1存回去，线程2存回去……
也就是说，数错了…………
怎么办呢……我们要使用一个互斥锁：获得了锁的线程现在才能干活，没有的只能等待
定义一个锁：

pthread_mutex_t lock;
相关的函数：
pthread_mutex_init(&lock,NULL); 初始化，后一个是属性，默认可以是NULL
pthread_mutex_lock(&lock);      加锁
pthread_mutex_unlock(&lock);    解开锁
pthread_mutex_destroy(&lock);   delete（？……大概就这么理解吧……）掉锁

代码：

 1 #include <pthread.h>
 2 #include <stdio.h>
 3 
 4 pthread_mutex_t lock;
 5 int tot = 0;
 6 
 7 void *entry_point(void *arg) {
 8     int * stat = (int*) arg;
 9     int i;
10     for (i = 0; i < *stat; i++) {
11         pthread_mutex_lock(&lock);
12         tot ++;
13         pthread_mutex_unlock(&lock);
14     }
15     return NULL;
16 }
17 
18 int main() {
19     pthread_t thr[2];
20     void *exit_status;
21     pthread_mutex_init(&lock,NULL);
22     int arr[2]; arr[0] = 10000; arr[1] = 20000;
23     pthread_create(&thr[0], NULL, &entry_point, &arr[0]);
24     pthread_create(&thr[1], NULL, &entry_point, &arr[1]);
25     pthread_join(thr[0],&exit_status);
26     pthread_join(thr[1],&exit_status);
27     printf("%d\n",tot);
28     pthread_mutex_destroy(&lock);
29     return 0;
30 }
31 


[NKU]sweet 2011-12-03 01:08 发表评论
]]>define 学习体会http://www.blogjava.net/sweetsc/archive/2011/12/02/365345.html[NKU]sweet[NKU]sweetThu, 01 Dec 2011 17:59:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/12/02/365345.htmlhttp://www.blogjava.net/sweetsc/comments/365345.htmlhttp://www.blogjava.net/sweetsc/archive/2011/12/02/365345.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/365345.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/365345.html 于是今天老图借了本书，学习一下……
来看一下我最头疼的define……
define的作用：
一是直接定义一个东西……类似标记
譬如：
1 #ifndef test
2 #define test
3 /*
4 balabalabala.
5 */
6 #endif
刘JX老师在大一C＋＋课上教育我们，写头文件一定要加上这么个东西……为什么呢……
再提一下include的事情…… #include<XXXX>，实际上是直接把XXXX整个文件COPY了进来……
如果出现这样的情况：
1 #include <set>
2 #include <map>
我们知道，Cpp的 map 实际上是用 set 做的，map的头文件里肯定有一个 #include <set>，那么，相当于set这个文件在这段程序里面出现了两次……
如果没有ifndef这套的话，相当于将set中的代码重复贴了两次，就粗大事了……
代码第一段ifndef test 代表：如果没有define test，则执行下面的那段，先 define test，然后balabala，最后endif，下次再看到这段代码的时候，ifndef test ，此时会发现test已经define过了，直接endif，中间balabala的代码不会重复两次……

二是直接定义一些……怎么说呢，类似替换规则的东西……

譬如：直接定义常量：
1 #define MAXN 10000
这个实际上就是直接在程序编译之前，将里面的MAXN都替换成10000
预先定义一些常量，好处大家都懂：避免程序内部太多的“magic number”，增强可读性，也便于修改……这里相当于直接替换，貌似C的数组，定义的时候不能用int做下标，const int也不行，只能通过这个方法，用立即数……

譬如：给一些东西改个名字：
  1 #include <stdio.h> 
  2 #define Q scanf 
  3  
  4 int main() { 
  5     int a; 
  6     Q("%d",&a); 
  7     printf("%d\n",a); 
  8     return 0; 
  9 } 

这里有一些玄机：
1：#似乎是因为没有转义？所以不能胡用……
譬如：#define USEMATH #include <math.h> 是不能达到预期效果的……
2：如果这一行太长，可以用\表示和下一行连起来…… 貌似这个'\'也没转义， #define BACKSLASH \ 也是不行的……

譬如：可以定义一些简单的函数：
#define max(a,b) ((a) > (b) ? (a) : (b))
某种意义上这比template NB...
这样，int c ＝ max(a,b); 就自动替换成 int c ＝((a) > (b) ? (a) : (b)); 了
此处有一个技巧：有的时候，咱们需要用大括号来实现这个"函数"，但是，由define直接替换知道，这个替换出来，相当于{/*balabala*/};这样，语法是错的……
于是怎么办呢……咱们可以用 do {/*balabala*/} while(0) 这样的形式，绕开这个问题…… 在上次OS大作业上咱们都见到了……
此处还有两个玄机：一是千万记得要加括号……为什么呢……
譬如：
#define mul(a,b) a * b
看着挺好，mul(1,2 + 3)就出事了…… 直接替换出来，是 1 * 2 + 3，就错了……
正确方法是：#define mul(a,b) ((a) * (b))，万无一失……
另一个玄机是避免++,--之类的，譬如
#define sqr(a) ((a) * (a))
sqr(a++)，如果sqr是真的函数的话，计算出没有问题……但是define会忠实的给你替换成((a++) * (a++))……怎么加的不重要，结果就不是你想的了……

最后有两个用法，一个是#，#会将你作为“函数”的“参数”传入的东西转化为字符串；一个是...，作用一看便知：
 1 #include <stdio.h>
 2 #define max(a,b) ((a) > (b) ? (a) : (b))
 3 #define PRINT() printf(__VA_ARGS__)
 4 #define debug(x) do { \
 5     PRINT(#x);  \
 6     PRINT(" = %d\n",(x)); \
 7     } while (0)
 8 
 9 int main() {
10     int a,b;
11     scanf("%d%d",&a,&b);
12     debug(a);
13     debug(b);
14     debug(a + b);
15     debug(max(a,b));
16     return 0;
17 }


[NKU]sweet 2011-12-02 01:59 发表评论
]]>pthread学习笔记http://www.blogjava.net/sweetsc/archive/2011/11/30/365156.html[NKU]sweet[NKU]sweetTue, 29 Nov 2011 16:15:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/11/30/365156.htmlhttp://www.blogjava.net/sweetsc/comments/365156.htmlhttp://www.blogjava.net/sweetsc/archive/2011/11/30/365156.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/365156.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/365156.htmlPDF教材传送门

前两天身心疲惫，现在得到了回复，于是乎工作还是要继续的……
近日从ACM界退休下来之后，在做并行计算的东西……
上周胡搞了一下，结果根本 TMD 搞不出来……决定静下心来，阅读一下入门手册，指南之类的
原文的作者假设咱们在UNIX操作系统下，于是也没有提安装配置的事情……
本人的 ArchLinux 也自带了pthread.h ，直接像stdio.h一样直接引用就好
编译时要加参数：-lpthread 或者 -pthread ……
两个函数：

pthread_create()：创建一个线程
第一个参数pthread_t *是类似线程ID一样的东西（经过查阅<bits/pthreadtypes.h>的定义，pthread_t就是long……）
第二个参数是线程的属性，使用NULL表示默认属性，咱们现在使用NULL就好
第三个参数是让这个线程执行的函数，这个函数的定义是void *(*__start_routine) (void *)，也就是说，参数和返回值都是void＊，这是个很好的做法，我们可以用结构体指针，来传递和返回多个值
第四个参数，就是第三个函数的void*参数

pthread_join()：等待某个线程结束
第一个参数：pthread_t，线程ID；第二个参数：void*，用来保存该线程执行的函数返回值
这两个函数return 0表示正常，否则表示有Bug……
咱们来看一下P5的习题：开10个线程，每个线程hello world五次，此时我自己发挥了一下，加了一个返回值：

 1 #include <pthread.h>
 2 #include <stdio.h>
 3 
 4 const int THREADS = 10;
 5 
 6 void *func(void *arg) {
 7     int i = 0;
 8     int *in = (int*) arg;
 9     for (i = 0; i < 5; i++) {
10         printf("Hello World (thread %d)\n",*in);
11     }
12     return in;
13 }
14 
15 int main() {
16     pthread_t thread_ID[THREADS];
17     void *exit_status;
18     int ID;
19     int arg[THREADS];
20     for (ID = 1; ID <= THREADS; ID++) {
21         arg[ID] = ID;
22         pthread_create(&thread_ID[ID], NULL, func, &arg[ID]);
23     }
24     for (ID = 1; ID <= THREADS; ID++) {
25         pthread_join(thread_ID[ID], &exit_status);
26         printf("Thread %d end !!\n", *(int*)exit_status);
27     }
28     return 0;
29 }

程序运行正常输出了若干hello world，并且正常退出
由输出可以看出，主线程输出的thread XX end ，和那10个线程的Hello world是穿插着运行的，并没有连续……
习题还有一项，说：将这个程序弄到别的机器上看看效果，我猜是不是用在单核机器上，效果会不一样呢……
打开虚拟机，运行结果表明，他是5条5条打的……可以大概猜到，多核才能发挥多线程的作用啊……
我试了试把pthread_join的部分注释了是什么效果……结果运行到主程序结束return 0，其他线程也消失了……

2.2章讲了这么一件事情：返回值的时候，千万不能犯一个悲剧的错误：
在C/C++里我们知道，函数要返回一个数组，怎么办呢……应该new出来一个并且返回，如果直接在函数内部 int arr[1000]; return arr; 这样的话，返回的指针是指向栈空间的，而arr指针指向的那块内存在函数退出的时候直接就没有了……
正确的方法是int *arr = new int[1000]; return arr; 这样数组是开在内存里的，在函数执行完毕之后，不会被回收
作者提醒我们，不是有个函数要返回void* 么…… 道理一样，不能在这个地方犯二……

今天先写到这里……未完待续……


[NKU]sweet 2011-11-30 00:15 发表评论
]]>上网，读书，笔记 Ihttp://www.blogjava.net/sweetsc/archive/2011/10/09/360233.html[NKU]sweet[NKU]sweetSat, 08 Oct 2011 16:20:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/10/09/360233.htmlhttp://www.blogjava.net/sweetsc/comments/360233.htmlhttp://www.blogjava.net/sweetsc/archive/2011/10/09/360233.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/360233.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/360233.html最近要做点什么……于是上网找找资料……
From stanford CS：

Panda (for Provenance and Data) is a new project whose goal is to address some limitations in existing provenance systems.
Panda，（来源和数据的缩写），是一个新项目，他的目标是：解决一些现有的来源系统（？！）的局限。
this short paper describes our overall plans for Panda, including:
这个短Paper描述了我们对Panda大局的规划，包括
a model that fully integrates data-based and process-based provenance;
一个完全结合了基于数据和基于进程的来源模型（？！？！）
a set of built-in operators for exploiting provenance after it has been captured;
一个为了在捕获来源之后进行扩展的嵌入式操作符集合
an ad-hoc query language over provenance together with data;
一个来源 -> 数据的点对点的操作语言
supporting the range from fine-grained to coarse-grained provenance;
支持范围从细纹理到粗纹理的来源
and addressing optimization problems involving eager versus lazy evaluation and data caching.
处理包括：需求和简单分析的平衡、数据缓冲等最优化问题

好吧……
研究研究什么叫 provenance systems：

找了个文章，Layering in Provenance Systems（在这玩意里面分层？……）

In digital systems, provenance is the record of the creation and modification of an object.
在数字系统中，来源是一个东西创造和修改的记录
Provenance provides answers to questions such as:
记录提供诸如此类问题的答案：
How does the ancestry of two objects differ?
为什么这两个东西的祖先不一样？
Are there source code files tainted by proprietary software?
有源代码被私有软件污染了（吗？……）
How was this object created?
这个东西是怎么制造出来的

似乎有点理解 来源 是个啥了……

正在理解 provenance systems 中……


[NKU]sweet 2011-10-09 00:20 发表评论
]]>2011ACM北京网络预选赛 F Machine scheduling (BUPT 216)http://www.blogjava.net/sweetsc/archive/2011/09/18/358932.html[NKU]sweet[NKU]sweetSun, 18 Sep 2011 14:56:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/09/18/358932.htmlhttp://www.blogjava.net/sweetsc/comments/358932.htmlhttp://www.blogjava.net/sweetsc/archive/2011/09/18/358932.html#Feedback3http://www.blogjava.net/sweetsc/comments/commentRss/358932.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/358932.html 首先，这个题要分成两个部分解决：
第一部分：从n个东西里面取出r个，每个间距至少为 k （1～K不行，1～K ＋ 1行）
第二部分：将这r个东西分成至多m组，可以有空组
第二部分貌似好久之前搞OI的时候干过……贴过来：
N球放在M个盒子里，求共有多少种放法

但是有3个不同的条件 ：N个球是否相同，M个盒子是否相同，是否允许有盒子空着

球和球

盒和盒

空盒

情况数

有区别

有区别

有空盒

mn

有区别

有区别

无空盒

M！s（n,m）

有区别

无区别

有空盒

S(n,1)+s(n,2)+…+s(n,m),n>=m

S(n,1)+s(n,2)+…+s(n,n),n<=m

有区别

无区别

无空盒

S(n,m)

无区别

有区别

有空盒

C(n+m-1,n)

无区别

有区别

无空盒

C(n-1,m-1)

无区别

无区别

有空盒

F(m,n)

无区别

无区别

无空盒

F(m,n-m)

然后，其中的F(m,n)貌似是当时写过的一个DP，S(M,N)是第二类stirling数……
递推公式：
1 int S(int n,int m) {
2     if (n == m || m == 1) return 1;
3     return m * S(n - 1, m) + S(n - 1, m - 1);
4 }
第一部分：可以看作这么一个生成函数的相关问题：由于每个东西之间都隔了>=K－1的一段距离，因此一个可行解可以看作，长度为K，K + 1，K + 2的棍子r － 1个（我们认为每个棍子的头是我们取的点），拼接成长度为Len的一个大段，之后再堵上一个，就是一个Len ＋１的可行解……
而r - 1根棍子，拼成长度为Len 的可行解数目，就是(X^K + X^(K + 1) + X^(K + 2) + .....) ^ (r - 1)，这个多项式，展开之后，X^Len项前面的系数……
不过……由于数据范围，直接搞是不成的……
于是提取，变形：X^(K * (r - 1))  * (1 + X + X^2 + X ^3 +....)^(r - 1)
然后再变形：X^(K * (r - 1))  * (1/(1 - x))^(r - 1)……
然后参照Matrix67大神的日志，展开后面那项：
1/(1-x)^n=1+C(n,1)x^1+C(n+1,2)x^2+C(n+2,3)x^3+...+C(n+k-1,k)x^k+...
我们知道，要求长度为len的可行数目，也就是要X^Len项前面的系数，然后，由于前面提取出来了一个K * (r - 1)，也就是去后面找len - K * (r - 1) 项的系数……
也就是说，令pow = len - K * (r - 1)，答案就是C(r - 1 + pow - 1, pow)……
不过这还没完，因为咱们要拼成的长度是len，而总的长度是N，需要乘上这个长度len的开头位置的可能数……
另外还需要特殊处理：咱们在处理的时候，是先用r - 1个拼接成长度为Len的一个大段，再堵上最后一个……当r == 1需要特判……
代码：
 1 #include <cstdio>
 2 #include <cstring>
 3 
 4 typedef long long Long;
 5 const Long MOD = 1000000007;
 6 
 7 Long F[1010][1010];
 8 Long C[2010][2010];
 9 Long S(int n,int m) {
10     if (n == m || m == 1) return 1LL;
11     if (F[n][m] > 0) return F[n][m];
12     return F[n][m] = (m * S(n - 1, m) % MOD + S(n - 1, m - 1)) % MOD;
13 }
14 void init() {
15     for (int i = 0; i <= 2000; i++) {
16         for (int j = 0; j <= i; j++) {
17             if (j == 0) C[i][j] = 1;
18             else C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
19         }
20     }
21 }
22 int n,r,k,m;
23 
24 int main() {
25     memset(F,0xff,sizeof(F));
26     init();
27     while (scanf("%d%d%d%d",&n,&r,&k,&m) > 0) {
28         if (r == 1) {printf("%d\n",n); continue;}
29         Long ans = 0;
30         for (int i = 1; i <= m && i <= r; i++) {
31             ans = (ans + S(r,i)) % MOD;
32         }
33         Long tmp = 0;
34         for (int len = k * (r - 1); len < n; len++) {
35             int left = n - len;
36             int pow = len - k * (r - 1);
37             // r > 1 !!
38             tmp = (tmp + left * C[r - 1 + pow - 1][pow]) % MOD;
39         }
40         ans = ans * tmp % MOD;
41         printf("%lld\n",ans);
42     }
43     return 0;
44 }


[NKU]sweet 2011-09-18 22:56 发表评论
]]>旁门左道第二章之障碍器http://www.blogjava.net/sweetsc/archive/2011/04/06/347696.html[NKU]sweet[NKU]sweetWed, 06 Apr 2011 04:36:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/04/06/347696.htmlhttp://www.blogjava.net/sweetsc/comments/347696.htmlhttp://www.blogjava.net/sweetsc/archive/2011/04/06/347696.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/347696.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/347696.html原始出处 、作者信息和本声明。否则他将追究法律责任……

Hmm……好怕怕，转个日志都会被追究法律责任……

不过要感谢原文的兰州，在兰州的文章帮助下，今天突然发现了灵感，改造了改造兰州的代码……
在ACM中的作用，我觉得可以这样：
1：对于单文件多case的题，开多线程，每个线程跑一个case，之后再调用收尾的任务输出
2：对于单case且可以并行的情况，开若干线程处理之后，调用收尾函数來最后处理、输出

以下是一个简单的求和代码，实际效果，在我的双核CPU上用时大概减少了一半

 1 import java.util.concurrent.BrokenBarrierException;
 2 import java.util.concurrent.CyclicBarrier;
 3 
 4 public class Test {
 5     public static int[] ans;
 6     void run() {
 7         ans = new int[4];
 8         int now = 0;
 9         for (int i = 0; i < 400000000; i++) {
10             now = (now + i) % 9999997;
11         }
12         System.out.println(now);
13         CyclicBarrier cb = new CyclicBarrier(4, new MainTask());
14         new SubTask(0,0,100000000,cb).start();
15         new SubTask(1,100000000,200000000,cb).start();
16         new SubTask(2,200000000,300000000,cb).start();
17         new SubTask(3,300000000,400000000,cb).start();
18     }
19     public static void main(String[] args) {
20         new Test().run();
21     }
22 }
23 
24 class MainTask implements Runnable {
25     public void run() {
26         int ans = 0;
27         for (int i = 0; i < 4; i++) {
28             ans = (ans + Test.ans[i]) % 9999997;
29         }
30         System.out.println(ans);
31     }
32 }
33 
34 class SubTask extends Thread {
35     private int pos;
36     private int left;
37     private int right;
38     private CyclicBarrier cb;
39     final int mod = 9999997;
40 
41     SubTask(int pos,int left,int right,CyclicBarrier cb) {
42         this.pos = pos;
43         this.left = left;
44         this.right = right;
45         this.cb = cb;
46     }
47 
48     public void run() {
49         int ans = 0;
50         for (int i = left; i < right; i++) {
51             ans = (ans + i) % mod;
52         }
53         Test.ans[pos] = ans;
54 
55         try {
56             cb.await();
57         } catch (InterruptedException e) {
58             e.printStackTrace();
59         } catch (BrokenBarrierException e) {
60             e.printStackTrace();
61         }
62     }
63 }


[NKU]sweet 2011-04-06 12:36 发表评论
]]>来个旁门左道……http://www.blogjava.net/sweetsc/archive/2011/03/21/346699.html[NKU]sweet[NKU]sweetMon, 21 Mar 2011 11:16:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/03/21/346699.htmlhttp://www.blogjava.net/sweetsc/comments/346699.htmlhttp://www.blogjava.net/sweetsc/archive/2011/03/21/346699.html#Feedback0http://www.blogjava.net/sweetsc/comments/commentRss/346699.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/346699.html 照书抄的，无须解释，看看估计就懂了……
但是把这个用在做题中会怎样呢？…… =_=

 1 import java.util.concurrent.Executors;
 2 import java.util.concurrent.ExecutorService;
 3 
 4 class SumTask implements Runnable {
 5     long Left;
 6     long Right;
 7     long ans;
 8     final long MOD = 199999997;
 9     SumTask(long L,long R) {
10         Left = L;
11         Right = R;
12     }
13     public void run() {
14         for (long i = Left; i < Right; i++) {
15             ans = (ans + i) % MOD;
16         }
17         System.out.println(ans);
18     }
19 }
20 
21 public class mul {
22     public static void main(String args[]) {
23         long MOD = 199999997;
24         long ans = 0;
25         for (long i = 0; i < 400000000; i++) {
26             ans = (ans + i) % MOD;
27         }
28         System.out.println(ans);
29         SumTask task1 = new SumTask(0,100000000);
30         SumTask task2 = new SumTask(100000000,200000000);
31         SumTask task3 = new SumTask(200000000,300000000);
32         SumTask task4 = new SumTask(300000000,400000000);
33         System.out.println("4 threads Start!!");
34         ExecutorService runner = Executors.newFixedThreadPool(4);
35         runner.execute(task1);
36         runner.execute(task2);
37         runner.execute(task3);
38         runner.execute(task4);
39         runner.shutdown();
40     }
41 }



[NKU]sweet 2011-03-21 19:16 发表评论
]]>贴个裸模板……求引玉……http://www.blogjava.net/sweetsc/archive/2011/02/23/344972.html[NKU]sweet[NKU]sweetWed, 23 Feb 2011 06:32:00 GMThttp://www.blogjava.net/sweetsc/archive/2011/02/23/344972.htmlhttp://www.blogjava.net/sweetsc/comments/344972.htmlhttp://www.blogjava.net/sweetsc/archive/2011/02/23/344972.html#Feedback3http://www.blogjava.net/sweetsc/comments/commentRss/344972.htmlhttp://www.blogjava.net/sweetsc/services/trackbacks/344972.html 1 import java.util.*;
 2 import java.io.*;
 3 import java.math.*;
 4 
 5 
 6 class Main {
 7     public static void main(String args[]) throws IOException {
 8         new Prob().solve();
 9     }
10 }
11 
12 class Prob {
13     void solve() throws IOException {
14         MyReader in = new MyReader();
15         //.
16     }
17     void debug(Objectx) {
18         System.out.println(Arrays.deepToString(x));
19     }
20 }
21 
22 class MyReader {
23     BufferedReader br = new BufferedReader (
24         new InputStreamReader (System.in));
25     StringTokenizer in;
26     String next() throws IOException {
27         while (in == null || !in.hasMoreTokens()) {
28             in = new StringTokenizer(br.readLine());
29         }
30         return in.nextToken();
31     }
32     int nextInt() throws IOException {
33         return Integer.parseInt(next());
34     }
35 }


[NKU]sweet 2011-02-23 14:32 发表评论
]]>