近日有很多人嘗試破解 win 7 Release Candidate, 轉為 OEM 版的Windows 7 Ultimate 。
但如何得知成功與否?
WINVER: 版本顯示器, 它可以快速打開顯示系統版本資訊的視窗, 包括版本及有否使用期限。
星期六, 10月 31, 2009
星期三, 10月 28, 2009
CS3161 (A) OPERATING SYSTEM PRINCIPLES (DR. LIU WENYIN) (09CS3161_LW) - Answers to Tutorial 7 Questions
Q1 What is a critical section problem ? What is a safe state ?
Critical Section Problem
- A critical section is a section of code, sharing or interacts with other processes in which only one process (among processes) at a time can be executing.
- Critical section problem involved in design an algorithm which allows at most one process into the critical section at a time, without deadlock.
Safe State
- A set of resource allocations such that the system can allocate resources to each process (up to its maximum requested resources) and in some order (completion sequence), and still avoid a deadlock.
Q2 Define deadlock and the four necessary conditions needed before deadlock can occur ?
A situation where every process is waiting for an event which can be triggered only by another process.
The four necessary conditions for deadlock to occur :
1 Mutual exclusion: At least one resource must be held in a non-sharable mode.
2 Hold and wait: A process holding at least one resource is waiting for more resources held by other processes.
3 No preemption: Resource cannot be preempted.
4 There must be a circular waiting condition for processes.
Question 3
Consider the following snapshot of a system. There are no current outstanding queued unsatisfied requests.
Maximum resources
r1 r2 r3 r4
6 7 12 12
current allocation maximum demand
process r1 r2 r3 r4 r1 r2 r3 r4
p1 0 0 1 2 0 0 1 2
p2 2 0 0 0 2 7 5 0
p3 0 0 3 4 6 6 5 6
p4 2 3 5 4 4 3 5 6
p5 0 3 3 2 0 6 5 2
Is this system current in a safe or unsafe state ? Why ?
needs
r1 r2 r3 r4
0 0 0 0
0 7 5 0
6 6 2 2
2 0 0 2
0 3 2 0
Running the Banker's Algorithm, we see processes can finished in the order p1, p4, p5, p2, p3. The system is in a safe state since there is a completion path.
Critical Section Problem
- A critical section is a section of code, sharing or interacts with other processes in which only one process (among processes) at a time can be executing.
- Critical section problem involved in design an algorithm which allows at most one process into the critical section at a time, without deadlock.
Safe State
- A set of resource allocations such that the system can allocate resources to each process (up to its maximum requested resources) and in some order (completion sequence), and still avoid a deadlock.
Q2 Define deadlock and the four necessary conditions needed before deadlock can occur ?
A situation where every process is waiting for an event which can be triggered only by another process.
The four necessary conditions for deadlock to occur :
1 Mutual exclusion: At least one resource must be held in a non-sharable mode.
2 Hold and wait: A process holding at least one resource is waiting for more resources held by other processes.
3 No preemption: Resource cannot be preempted.
4 There must be a circular waiting condition for processes.
Question 3
Consider the following snapshot of a system. There are no current outstanding queued unsatisfied requests.
Maximum resources
r1 r2 r3 r4
6 7 12 12
current allocation maximum demand
process r1 r2 r3 r4 r1 r2 r3 r4
p1 0 0 1 2 0 0 1 2
p2 2 0 0 0 2 7 5 0
p3 0 0 3 4 6 6 5 6
p4 2 3 5 4 4 3 5 6
p5 0 3 3 2 0 6 5 2
Is this system current in a safe or unsafe state ? Why ?
needs
r1 r2 r3 r4
0 0 0 0
0 7 5 0
6 6 2 2
2 0 0 2
0 3 2 0
Running the Banker's Algorithm, we see processes can finished in the order p1, p4, p5, p2, p3. The system is in a safe state since there is a completion path.
星期三, 10月 21, 2009
一項數學挑戰^^-你若是工程師，你應該可在三分鐘內解開這道題!!
答案是多少啊? 算的出來嗎?
這是項數學挑戰！有這麼一種說法：
你若是工程師，你應該可在三分鐘內（３０秒左右吧）解開這道題；你若是建築師，給你三小時；你若是醫生，給你六小時；你若是會計師，三個月吧～假若你是律師，大概永遠也解不出來。
你若擅長數學或邏輯性的問題，解開這道挑戰題，並以答案為密碼，打開附件，將你的名字加在名人堂裡面。
問題如下：空格中的數字為？
1, 2, 6, 42, 1806, ____???
答案就是密碼，可以打開附件檔案。你若能順利解題，請將你的名字加上，存檔後再
寄給你的朋友^^
==========================
答案: 3263442
1st: 1
2nd: 1 + 1X1
3rd: 2 + 2x2
4th: 6 + 6x6
5th: 42 + 42x42
6th: 1806 + 1806x1806
這是項數學挑戰！有這麼一種說法：
你若是工程師，你應該可在三分鐘內（３０秒左右吧）解開這道題；你若是建築師，給你三小時；你若是醫生，給你六小時；你若是會計師，三個月吧～假若你是律師，大概永遠也解不出來。
你若擅長數學或邏輯性的問題，解開這道挑戰題，並以答案為密碼，打開附件，將你的名字加在名人堂裡面。
問題如下：空格中的數字為？
1, 2, 6, 42, 1806, ____???
答案就是密碼，可以打開附件檔案。你若能順利解題，請將你的名字加上，存檔後再
寄給你的朋友^^
==========================
答案: 3263442
1st: 1
2nd: 1 + 1X1
3rd: 2 + 2x2
4th: 6 + 6x6
5th: 42 + 42x42
6th: 1806 + 1806x1806
星期二, 10月 20, 2009
CS3161 (A) OPERATING SYSTEM PRINCIPLES (DR. LIU WENYIN) (09CS3161_LW) - Answers to Tutorial 6 Questions
Q1 Study of The Producer-Consumer Problem (Bounded Buffer Problem)(i) Using pseudo code to represent the problem;(ii) Provides a solution using semaphore;(iii) Provides a solution using monitor;
(i) Description of the problem
. Two processes share a common, fixed-size buffer
. One process, the producer, puts data into the buffer, the other process, the consumer, takes it out.
. When producer wants to put a datum into the buffer, but it is full, producer goes to sleep, to be awakened when the consumer removes one or more data.
. When consumer wants to remove a datum from the buffer, when the buffer is empty, consumer goes to sleep, until producer put one datum into the buffer.
nRepresentation of the producer-consumer problem
. count = variable, to keep track of the number of data in buffer
N = maximum number of data number the buffer can hold
. consumer test count,
either count = 0 , go to sleep
or count = count -1
. each process tests if the other process should be sleeping, if not, wakes it up
. SLEEP and WAKEUP are system call for process manipulation
. enter_data and remove_data are procedures for putting and taking data in and out of the buffer
Code representing the Producer-consumer problem :
#include “prototypes.h”
#define N 100 /* number of slots in the buffer */
int count = 0; /* number of data items in buffer */
void producer (void)
{
int data;
while (TRUE) { /* repeat forever */
data = produce_data(); /* generate next data */
if (count == N) sleep(); /* if buffer is full, go to sleep */
enter_data(data); /* put data in buffer */
count ++; /* increment count of data number in buffer */
if (count == 1) wakeup(consumer); /* buffer not empty now and can be consumed now, notify consumer…*/
}
}
void consumer(void)
{
int data;
while (TRUE) { /* repeat forever */
if (count == 0) sleep(); /* if buffer is empty, go to sleep */
data = remove_data(); /* take data out of buffer */
count --; /* decrement count of data number in buffer */
if (count == N -1) wakeup(producer); /* buffer becomes not full and can be put more data, should notify producer */
consume_data(data); /* print data */
}
}
. Race Condition can occur executing the above code :
count++ could be implemented as
register1 = count
register1 = register1 + 1
count = register1
count-- could be implemented as
register2 = count
register2 = register2 - 1
count = register2
Consider this execution interleaving with “count = 5” initially:
S0: producer execute register1 = count {register1 = 5}
S1: producer execute register1 = register1 + 1 {register1 = 6}
S2: consumer execute register2 = count {register2 = 5}
S3: consumer execute register2 = register2 - 1 {register2 = 4}
S4: producer execute count = register1 {count = 6 }
S5: consumer execute count = register2 {count = 4}
(ii) Semaphores
. Semaphore is an integer variable
. When semaphore = 0, no resource is available
when semaphore > 0, # of resource abailable
. Semaphore can be operated in two operations ( Wait, Signal) :
Wait (sleep)
(i) checks to see if the semaphore value > 0 or = 0
(ii) if semaphore > 0, decrement the value, process execute critical section…,
if semaphore = 0, process put to sleep
Signal (wakeup)
(i) increment semaphore by 1
(ii) one of the sleeping process is awaken
. Wait () and Signal () operations are all done as a single, indivisible atomic action
. Signal and Wait are implemented as system calls; interrupts are disabled during execution to ensure atomic action ( protected by a lock variable mutex if necessary, as mutual exclusion)
The producer-consumer problem using semaphore
. Three semaphores are used :
full - counting the number of slots that are full.
empty - counting the number of slots that are empty.
The full and empty semaphores ensure that producer stops running when the buffer is full, consumer stops running when it is empty.
mutex - to make sure consumer and producer do no access the buffer at the same time.
mutex = 0 , no process can operate on semaphore ;
mutex = 1, process can perform Signal or Wait.
. Initially :
full = 0
empty = number of slot in the buffer.
mutex = 1 (can only take 1 or 0 - binary semaphore).
. Each process does a Wait before entering its critical region,
a Signal after leaving the critical region.
#include “prototypes.h”
#define N 100 /* number of slots in the buffer */
typedef int semaphore; /* semaphores are a special kind of int */
semaphore mutex = 1; /* controls access to critical region */
semaphore empty = N; /* counts empty buffer slots */
semaphore full = 0; /* counts full buffer slots */
void producer(void)
{
int data;
while (TRUE) { /* TRUE is the constant 1 */
data = produce_data(); /* generate data to put in buffer */
Wait(&empty); /* decrement empty count */
Wait(&mutex); /* enter critical region */
enter_data(data); /* put new data in buffer */
Signal(&mutex); /* leave critical region */
Signal(&full); /* increment count of full slots */
}
}
void consumer(void)
{
int data;
while (TRUE) { /* infinite loop */
Wait(&full); /* decrement full count */
Wait(&mutex); /* enter critical region */
data = remove_data(); /* take data from buffer */
Signal(&mutex); /* leave critical region */
Signal(&empty); /* increment count of empty slots */
consume_data(data); /* do something with the data */
}
}
(iii) Monitors
. monitor - a collection of procedures, variables and data structures in a package
. only one process can be active in a monitor at any instant
. compiler knows they are special monitor procedures (different from other procedure calls) and ensure only one process allows in the monitor, otherwise the calling process will be suspended until other process has left (mutual exclusion).
. Example of a monitor :
monitor example
integer i;
condition c;
procedure producer(x);
…
…
end;
procedure consumer(x);
…
…
end;
end monitor;
. A way for process to block when they cannot proceed - condition variables and operations WAIT and SIGNAL
When a monitor procedure finds that it cannot continue (such as for producer finds the buffer is full), it WAIT on the condition variable, full. The calling process will block itself, allowing another process (previously been blocked) to enter monitor
When a process (such as the consumer) wake up other sleeping process by doing a SIGNAL on the condition variable that other process is waiting on and must exited from the monitor immediately. SIGNAL must appear as the last statement (before exit) in a monitor.
The WAIT must come before the SIGNAL
Solution for the producer-consumer problem using monitor :
monitor ProducerConsumer
condition full, empty;
integer count, N;
function enter(data:integer);
begin
if count = N then wait(full);
enter_data(data);
count := count + 1;
if count = 1 then signal(empty)
end;
function remove(data:integer);
begin
if count = 0 then wait(empty);
data = remove_data;
count := count - 1;
if count = N - 1 then signal(full)
end;
count := 0;
end monitor;
procedure producer;
begin
while true do
begin
data = produce_data;
ProducerConsumer.enter(data)
end
end;
procedure consumer;
begin
while true do
begin
ProducerConsumer.remove;
consume_data(data)
end
end;
. monitors are a programming language concept and monitor procedures must be recognised by compiler to enforce mutual exclusion.
(i) Description of the problem
. Two processes share a common, fixed-size buffer
. One process, the producer, puts data into the buffer, the other process, the consumer, takes it out.
. When producer wants to put a datum into the buffer, but it is full, producer goes to sleep, to be awakened when the consumer removes one or more data.
. When consumer wants to remove a datum from the buffer, when the buffer is empty, consumer goes to sleep, until producer put one datum into the buffer.
nRepresentation of the producer-consumer problem
. count = variable, to keep track of the number of data in buffer
N = maximum number of data number the buffer can hold
. consumer test count,
either count = 0 , go to sleep
or count = count -1
. each process tests if the other process should be sleeping, if not, wakes it up
. SLEEP and WAKEUP are system call for process manipulation
. enter_data and remove_data are procedures for putting and taking data in and out of the buffer
Code representing the Producer-consumer problem :
#include “prototypes.h”
#define N 100 /* number of slots in the buffer */
int count = 0; /* number of data items in buffer */
void producer (void)
{
int data;
while (TRUE) { /* repeat forever */
data = produce_data(); /* generate next data */
if (count == N) sleep(); /* if buffer is full, go to sleep */
enter_data(data); /* put data in buffer */
count ++; /* increment count of data number in buffer */
if (count == 1) wakeup(consumer); /* buffer not empty now and can be consumed now, notify consumer…*/
}
}
void consumer(void)
{
int data;
while (TRUE) { /* repeat forever */
if (count == 0) sleep(); /* if buffer is empty, go to sleep */
data = remove_data(); /* take data out of buffer */
count --; /* decrement count of data number in buffer */
if (count == N -1) wakeup(producer); /* buffer becomes not full and can be put more data, should notify producer */
consume_data(data); /* print data */
}
}
. Race Condition can occur executing the above code :
count++ could be implemented as
register1 = count
register1 = register1 + 1
count = register1
count-- could be implemented as
register2 = count
register2 = register2 - 1
count = register2
Consider this execution interleaving with “count = 5” initially:
S0: producer execute register1 = count {register1 = 5}
S1: producer execute register1 = register1 + 1 {register1 = 6}
S2: consumer execute register2 = count {register2 = 5}
S3: consumer execute register2 = register2 - 1 {register2 = 4}
S4: producer execute count = register1 {count = 6 }
S5: consumer execute count = register2 {count = 4}
(ii) Semaphores
. Semaphore is an integer variable
. When semaphore = 0, no resource is available
when semaphore > 0, # of resource abailable
. Semaphore can be operated in two operations ( Wait, Signal) :
Wait (sleep)
(i) checks to see if the semaphore value > 0 or = 0
(ii) if semaphore > 0, decrement the value, process execute critical section…,
if semaphore = 0, process put to sleep
Signal (wakeup)
(i) increment semaphore by 1
(ii) one of the sleeping process is awaken
. Wait () and Signal () operations are all done as a single, indivisible atomic action
. Signal and Wait are implemented as system calls; interrupts are disabled during execution to ensure atomic action ( protected by a lock variable mutex if necessary, as mutual exclusion)
The producer-consumer problem using semaphore
. Three semaphores are used :
full - counting the number of slots that are full.
empty - counting the number of slots that are empty.
The full and empty semaphores ensure that producer stops running when the buffer is full, consumer stops running when it is empty.
mutex - to make sure consumer and producer do no access the buffer at the same time.
mutex = 0 , no process can operate on semaphore ;
mutex = 1, process can perform Signal or Wait.
. Initially :
full = 0
empty = number of slot in the buffer.
mutex = 1 (can only take 1 or 0 - binary semaphore).
. Each process does a Wait before entering its critical region,
a Signal after leaving the critical region.
#include “prototypes.h”
#define N 100 /* number of slots in the buffer */
typedef int semaphore; /* semaphores are a special kind of int */
semaphore mutex = 1; /* controls access to critical region */
semaphore empty = N; /* counts empty buffer slots */
semaphore full = 0; /* counts full buffer slots */
void producer(void)
{
int data;
while (TRUE) { /* TRUE is the constant 1 */
data = produce_data(); /* generate data to put in buffer */
Wait(&empty); /* decrement empty count */
Wait(&mutex); /* enter critical region */
enter_data(data); /* put new data in buffer */
Signal(&mutex); /* leave critical region */
Signal(&full); /* increment count of full slots */
}
}
void consumer(void)
{
int data;
while (TRUE) { /* infinite loop */
Wait(&full); /* decrement full count */
Wait(&mutex); /* enter critical region */
data = remove_data(); /* take data from buffer */
Signal(&mutex); /* leave critical region */
Signal(&empty); /* increment count of empty slots */
consume_data(data); /* do something with the data */
}
}
(iii) Monitors
. monitor - a collection of procedures, variables and data structures in a package
. only one process can be active in a monitor at any instant
. compiler knows they are special monitor procedures (different from other procedure calls) and ensure only one process allows in the monitor, otherwise the calling process will be suspended until other process has left (mutual exclusion).
. Example of a monitor :
monitor example
integer i;
condition c;
procedure producer(x);
…
…
end;
procedure consumer(x);
…
…
end;
end monitor;
. A way for process to block when they cannot proceed - condition variables and operations WAIT and SIGNAL
When a monitor procedure finds that it cannot continue (such as for producer finds the buffer is full), it WAIT on the condition variable, full. The calling process will block itself, allowing another process (previously been blocked) to enter monitor
When a process (such as the consumer) wake up other sleeping process by doing a SIGNAL on the condition variable that other process is waiting on and must exited from the monitor immediately. SIGNAL must appear as the last statement (before exit) in a monitor.
The WAIT must come before the SIGNAL
Solution for the producer-consumer problem using monitor :
monitor ProducerConsumer
condition full, empty;
integer count, N;
function enter(data:integer);
begin
if count = N then wait(full);
enter_data(data);
count := count + 1;
if count = 1 then signal(empty)
end;
function remove(data:integer);
begin
if count = 0 then wait(empty);
data = remove_data;
count := count - 1;
if count = N - 1 then signal(full)
end;
count := 0;
end monitor;
procedure producer;
begin
while true do
begin
data = produce_data;
ProducerConsumer.enter(data)
end
end;
procedure consumer;
begin
while true do
begin
ProducerConsumer.remove;
consume_data(data)
end
end;
. monitors are a programming language concept and monitor procedures must be recognised by compiler to enforce mutual exclusion.
星期一, 10月 19, 2009
情人節該送多少枝玫瑰花
玫瑰花象徵愛情，為萬花中之女王，為世人所鐘愛。玫瑰花在日本古代稱為庚甲花、月季花或長壽花；是因一年當中庚甲之季第一朵玫瑰花開花，並一年開多次花，故又名長壽花。
送不同數目的玫瑰花，有著不同的心意。
1朵 你是唯一 2朵 你儂我儂
3朵 我愛你 4朵 誓言;承諾
5朵 無悔 6朵 順利
7朵 喜相逢 8朵 彌補
9朵 堅定的愛 10朵 完美的你;十全十美
11朵 一心一意;最美 12朵 心心相印
13朵 暗戀 17朵 好聚好散
20朵 此情不渝 21朵 最愛
22朵 雙雙對對 24朵 思念
33朵 我愛你;三生三世 36朵 海誓山盟
44朵 至死不渝 50朵 無悔的愛
56朵 吾愛 57朵 吾愛吾妻
66朵 情場順利;真愛不變 77朵 有緣相逢
88朵 用心彌補 99朵 長相守
100朵 白頭偕老;百年好合 101朵 唯一的愛
108朵 求婚 111朵 無盡的愛
144朵 愛你生生世世 365朵 天天想你
999朵 天長地久 1001朵 直到永遠
送不同數目的玫瑰花，有著不同的心意。
1朵 你是唯一 2朵 你儂我儂
3朵 我愛你 4朵 誓言;承諾
5朵 無悔 6朵 順利
7朵 喜相逢 8朵 彌補
9朵 堅定的愛 10朵 完美的你;十全十美
11朵 一心一意;最美 12朵 心心相印
13朵 暗戀 17朵 好聚好散
20朵 此情不渝 21朵 最愛
22朵 雙雙對對 24朵 思念
33朵 我愛你;三生三世 36朵 海誓山盟
44朵 至死不渝 50朵 無悔的愛
56朵 吾愛 57朵 吾愛吾妻
66朵 情場順利;真愛不變 77朵 有緣相逢
88朵 用心彌補 99朵 長相守
100朵 白頭偕老;百年好合 101朵 唯一的愛
108朵 求婚 111朵 無盡的愛
144朵 愛你生生世世 365朵 天天想你
999朵 天長地久 1001朵 直到永遠
星期日, 10月 18, 2009
5个笑话
5个笑话解读男女区别
1、关于本能
一家专营女性婚姻服务的店在市中心全新开张，女人们可以直接进去挑选—个心仪的配偶。在店门口，立了一面告示牌：—个人只能进去逛—次!店里共有六层楼，随着高度的上升，男人的质量也越高，不过请注意，顾客能在任何一层楼选—个丈夫或者选择上楼，但不能回到以前逛过的楼层……
—个女人来这家店寻找—个老公。
一楼写着：这里的男人有工作。女人看也不看就上了第二层楼，
二楼写着：这里的男人有工作而且热爱小孩。女人上了三楼，
三楼写着：这里的男人有工作而且热爱小孩，还很帅。哇！她叹道，但仍强迫自己往上爬。
四楼：这里的男人有工作而且热爱小孩。令人窒息的帅，还会帮忙做家务。哇！饶了我吧！女人叫道，我快站不住脚了！接着她仍然爬上了五楼。
五楼：这里的男人有工作而且热爱小孩，令人窒息的帅，还会帮忙做家务，更有着强烈的浪漫情怀。女人简直想留在这一层楼，但仍抱着满腹期待走向最高一层。
第六楼出现了一面巨大的电子告示板，上面写道：你是这层楼的第123456789位访客，这里不存在任何男人，这层楼的存在只是为了证明女人有多么不可能取悦。谢谢光临……
不久，一家专营男性婚姻服务的店在街对面开张，经营方式与前者—模—样。第一层的女人长得漂亮。第二层的女人长得漂亮并且有钱……结果，二层以上，第三层至六层的楼层从来没有男人上去过……
解读：女人的本能是幻想。男人的本能是现实。这就是为什么优秀的剩女永远多于优秀的剩男的原因，也是为什么婚姻里的怨女多过怨男的理由。与其两手空空，还是抓住现有的优点吧，和爱人的优点过日子。
2、关于信任
—个女人有—晚没回家，隔天跟老公说自己睡在—个女性朋友那里，她老公打电话给她最好的1O个朋友，没有—个朋友知道这件事！
—个男人有—晚没回家睡，隔天他跟老婆说他睡在—个兄弟那里，她老婆打电话给他最好的10个朋友，有8个好兄弟确定她老公睡在他们家……
还有2个说：“今天你老公还在我那儿！”
某人把此帖给老婆看，没想到他老婆兴致大发，立刻打电话给他的朋友问他是否在他们那里。结果可想而知，再次论证了上述观点！更离谱的是有一哥们竟然说他在他家喝醉了，正睡着呢，还问他老婆要不要喊他起来接电话？
在挂了电话后，那哥们的电话马上打到他手机上，一接通没等他说话就大喊：在哪呢？快回家吧，你老婆找你呢，我说你在我家喝醉了……回去前别忘了先喝酒……通完话，他看着老婆默默无语……
解读：我们都听过狼来了的故事。却不知道自己每天都在喊着狼来了。当我们口口声声要求对方的信任时。不要忘了信任的另一面是问心无愧。
3、关于性别
男生用提款卡领钱：把车停在提款机旁，插入提款卡，按入密码，拿钱，取卡和收据。
女生用提款卡领钱：把车停在提款机旁，用后视镜补补妆，把引擎熄火，把钥匙放在皮包里，下车。翻遍皮包找提款卡，插入提款卡，翻遍皮包找那张写有密码的口香糖锡箔纸，按入密码，读屏幕上的指示，花掉两分钟。按取消键，重新输入正确的密码，查询账户结余，再读一次屏幕指示，选择提取现金。走进车子，用后视镜补补妆，翻遍皮包找钥匙，发动引擎，开了5米停止。倒车回到ATM，用后视镜补补妆，下车，拿钱、提款卡和收据，上车，用后视镜补补妆，翻遍皮包找个位置放提款卡。换倒挡，排档，开车。开了十公里后，把手刹放掉。
解读：看完此文，终于明白为什么上帝要在制造男人后又制造出女人，因为两者的完全不可替代性。所以不要要求男人像女人那样细心体贴吧,就像不要要求女人像男人那样干脆果断。
4、关于改变
热恋的时候，男人抱着女人睡。女人说：你抱得我太紧了，我快窒息了。男人笑着说：喜欢抱着你，否则我睡不着。当他们成为夫妻以后，有一天女人投诉：你晚上睡觉都没抱着我，这和我—个人睡有什么分别？男人说：抱在一起，大家都睡不好，难道你不觉得吗？
某天，男人会突然在闹市中把女人抱起，走长长的一段路。女人笑说：你疯了吗？快把我放下来，让人看到不好。男人说：怕什么？我喜欢抱着你。若干年以后，女人在闹市中向男人撒娇：抱我!男人说：你疯了吗？
某天，女人跟男人说：抱我！男人乖乖弯腰，把女人抱上床。若干年以后，女人跟男人说：抱我上床！男人没好气地说：你脚断了吗？
某天，男人向女人许诺：即使你将来变成—个大肥婆，我也要天天抱你；你变成老太婆，我也继续抱着你。若干年之后，女人胖了，老了，要男人抱。男人没好气地说：你想压死我吗？
解读：很难相信，当天抱你和若干年之后不抱你的，竟是同—个男人。
5、关于需求
0-5岁：女→妈妈 / 男→妈妈。
6-10岁：女→不是讨厌的男孩子就可以了 / 男→可以陪我欺负女孩子的男孩
11-15岁：女→十五六七八岁的大哥哥 / 男→足球，篮球，网球，乒乓球……
16-20岁：女→十七八岁大家都称赞的“大帅哥” / 男→女人，女人就可以了！
21-25岁：女→25-29岁的男人，有事业、品位、才华…… / 男→20～24岁漂亮又有身材的女人
26-30岁：女→仍是坚持要比自己年纪大的男人 / 男→20～24岁漂亮又有身材的女人
30-40岁：女→心灵契合的好男人 / 男→20～24岁漂亮又有身材的女人
40-50岁：女→男人 / 男→20～24岁漂亮又有身材的女人
50-60岁：女→可与她终老的男人 / 男→20～24岁漂亮又有身材的女人
70-80岁：女→五六十岁时找到的那个，不需要自己照顾 / 男→20～24岁漂亮又有身材的女人
80-90岁：女→比自己迟死的男人 / 男→虽然我已经老花眼，看不清楚……但是我还是希望是20～24岁……
总结：男人打从20岁后，对女人的需求就十分专一！
解读：女人，25岁前尽情恋爱。25岁以后就彻底告别爱情梦想吧，与其把梦寄托在男人身上，不如把梦寄托在自己身上，反正，男人从20岁以后就没救
1、关于本能
一家专营女性婚姻服务的店在市中心全新开张，女人们可以直接进去挑选—个心仪的配偶。在店门口，立了一面告示牌：—个人只能进去逛—次!店里共有六层楼，随着高度的上升，男人的质量也越高，不过请注意，顾客能在任何一层楼选—个丈夫或者选择上楼，但不能回到以前逛过的楼层……
—个女人来这家店寻找—个老公。
一楼写着：这里的男人有工作。女人看也不看就上了第二层楼，
二楼写着：这里的男人有工作而且热爱小孩。女人上了三楼，
三楼写着：这里的男人有工作而且热爱小孩，还很帅。哇！她叹道，但仍强迫自己往上爬。
四楼：这里的男人有工作而且热爱小孩。令人窒息的帅，还会帮忙做家务。哇！饶了我吧！女人叫道，我快站不住脚了！接着她仍然爬上了五楼。
五楼：这里的男人有工作而且热爱小孩，令人窒息的帅，还会帮忙做家务，更有着强烈的浪漫情怀。女人简直想留在这一层楼，但仍抱着满腹期待走向最高一层。
第六楼出现了一面巨大的电子告示板，上面写道：你是这层楼的第123456789位访客，这里不存在任何男人，这层楼的存在只是为了证明女人有多么不可能取悦。谢谢光临……
不久，一家专营男性婚姻服务的店在街对面开张，经营方式与前者—模—样。第一层的女人长得漂亮。第二层的女人长得漂亮并且有钱……结果，二层以上，第三层至六层的楼层从来没有男人上去过……
解读：女人的本能是幻想。男人的本能是现实。这就是为什么优秀的剩女永远多于优秀的剩男的原因，也是为什么婚姻里的怨女多过怨男的理由。与其两手空空，还是抓住现有的优点吧，和爱人的优点过日子。
2、关于信任
—个女人有—晚没回家，隔天跟老公说自己睡在—个女性朋友那里，她老公打电话给她最好的1O个朋友，没有—个朋友知道这件事！
—个男人有—晚没回家睡，隔天他跟老婆说他睡在—个兄弟那里，她老婆打电话给他最好的10个朋友，有8个好兄弟确定她老公睡在他们家……
还有2个说：“今天你老公还在我那儿！”
某人把此帖给老婆看，没想到他老婆兴致大发，立刻打电话给他的朋友问他是否在他们那里。结果可想而知，再次论证了上述观点！更离谱的是有一哥们竟然说他在他家喝醉了，正睡着呢，还问他老婆要不要喊他起来接电话？
在挂了电话后，那哥们的电话马上打到他手机上，一接通没等他说话就大喊：在哪呢？快回家吧，你老婆找你呢，我说你在我家喝醉了……回去前别忘了先喝酒……通完话，他看着老婆默默无语……
解读：我们都听过狼来了的故事。却不知道自己每天都在喊着狼来了。当我们口口声声要求对方的信任时。不要忘了信任的另一面是问心无愧。
3、关于性别
男生用提款卡领钱：把车停在提款机旁，插入提款卡，按入密码，拿钱，取卡和收据。
女生用提款卡领钱：把车停在提款机旁，用后视镜补补妆，把引擎熄火，把钥匙放在皮包里，下车。翻遍皮包找提款卡，插入提款卡，翻遍皮包找那张写有密码的口香糖锡箔纸，按入密码，读屏幕上的指示，花掉两分钟。按取消键，重新输入正确的密码，查询账户结余，再读一次屏幕指示，选择提取现金。走进车子，用后视镜补补妆，翻遍皮包找钥匙，发动引擎，开了5米停止。倒车回到ATM，用后视镜补补妆，下车，拿钱、提款卡和收据，上车，用后视镜补补妆，翻遍皮包找个位置放提款卡。换倒挡，排档，开车。开了十公里后，把手刹放掉。
解读：看完此文，终于明白为什么上帝要在制造男人后又制造出女人，因为两者的完全不可替代性。所以不要要求男人像女人那样细心体贴吧,就像不要要求女人像男人那样干脆果断。
4、关于改变
热恋的时候，男人抱着女人睡。女人说：你抱得我太紧了，我快窒息了。男人笑着说：喜欢抱着你，否则我睡不着。当他们成为夫妻以后，有一天女人投诉：你晚上睡觉都没抱着我，这和我—个人睡有什么分别？男人说：抱在一起，大家都睡不好，难道你不觉得吗？
某天，男人会突然在闹市中把女人抱起，走长长的一段路。女人笑说：你疯了吗？快把我放下来，让人看到不好。男人说：怕什么？我喜欢抱着你。若干年以后，女人在闹市中向男人撒娇：抱我!男人说：你疯了吗？
某天，女人跟男人说：抱我！男人乖乖弯腰，把女人抱上床。若干年以后，女人跟男人说：抱我上床！男人没好气地说：你脚断了吗？
某天，男人向女人许诺：即使你将来变成—个大肥婆，我也要天天抱你；你变成老太婆，我也继续抱着你。若干年之后，女人胖了，老了，要男人抱。男人没好气地说：你想压死我吗？
解读：很难相信，当天抱你和若干年之后不抱你的，竟是同—个男人。
5、关于需求
0-5岁：女→妈妈 / 男→妈妈。
6-10岁：女→不是讨厌的男孩子就可以了 / 男→可以陪我欺负女孩子的男孩
11-15岁：女→十五六七八岁的大哥哥 / 男→足球，篮球，网球，乒乓球……
16-20岁：女→十七八岁大家都称赞的“大帅哥” / 男→女人，女人就可以了！
21-25岁：女→25-29岁的男人，有事业、品位、才华…… / 男→20～24岁漂亮又有身材的女人
26-30岁：女→仍是坚持要比自己年纪大的男人 / 男→20～24岁漂亮又有身材的女人
30-40岁：女→心灵契合的好男人 / 男→20～24岁漂亮又有身材的女人
40-50岁：女→男人 / 男→20～24岁漂亮又有身材的女人
50-60岁：女→可与她终老的男人 / 男→20～24岁漂亮又有身材的女人
70-80岁：女→五六十岁时找到的那个，不需要自己照顾 / 男→20～24岁漂亮又有身材的女人
80-90岁：女→比自己迟死的男人 / 男→虽然我已经老花眼，看不清楚……但是我还是希望是20～24岁……
总结：男人打从20岁后，对女人的需求就十分专一！
解读：女人，25岁前尽情恋爱。25岁以后就彻底告别爱情梦想吧，与其把梦寄托在男人身上，不如把梦寄托在自己身上，反正，男人从20岁以后就没救
星期四, 10月 15, 2009
CS3161 (A) OPERATING SYSTEM PRINCIPLES (DR. LIU WENYIN) (09CS3161_LW) - Answers to Tutorial 5 Questions
Q1 Define the difference between Preemptive and Non-preemptive scheduling. State why strict non-preemptive scheduling is unlikely to be used in a computer centre, suggest a better scheme for interactive users.
Preemptive scheduling allows a process to be interrupted in the midst of its execution, taking the CPU away from it and allocating it to another process.
Non-preemptive scheduling ensures that a process relinquishes control of the CPU only when it finishes with its current burst.
Non-preemptive would not likely be used in a computer centre, especially in a time sharing system, because it cannot guarantee that each user gets a share of the CPU at regular intervals. Non-preemptiveness allows programs to run infinitely long thus making turnaround time (response time) for other submitted jobs even longer.
Round-Robin is a preemptive scheme that makes use of interrupt/context switching operation to allow processor switching between jobs. Long jobs cannot delay shorter ones, because short jobs are guaranteed of getting the processor periodically. Interactive users will thus receive the processor frequently enough to maintain good response times.
Q2 Explain the difference in degree to which the following scheduling algorithms discriminate in favour of short jobs.(i) First Come, First Served(ii) Round Robin(iii) Multi-level feedback queues
(i) First Come, First Served (FCFS) - discriminates against short jobs since any short jobs arriving after long jobs will have a long waiting time.
(ii) Round-Robin - treats all jobs equally (giving them equal bursts of CPU time) so short jobs will be able to leave the system faster since they will finish first.
(iii) Multi-Level Feedback Queues - discriminate very favourably toward short jobs since it works similar to the round robin algorithm.
Q3 What effect does the size of time quantum have on the performance of a round robin (RR) algorithm?
At one extreme, if the time quantum is extremely large, the RR policy is the same as the FCFS policy. If the time quantum is small, it must be large with respect to context switch, otherwise overhead is too high.
Q4 What advantage is there in having different quantum sizes on different levels of a multi-level feedback queuing system ?
The advantage is that the short jobs will have highest priority if they are shorter than the initial quantum. This serves them fast and frees the CPU to concentrate on longer jobs.
The jobs that are pushed to the next level (lower priority), now can be given more time than the initial quantum since the goal is to run as many programs as fast as possible with minimal delays to other programs.
Therefore, by increasing the quantum with the level, shorter jobs will be allowed higher priority, and longer jobs will be allowed to run simultaneously with minimum delays.
Preemptive scheduling allows a process to be interrupted in the midst of its execution, taking the CPU away from it and allocating it to another process.
Non-preemptive scheduling ensures that a process relinquishes control of the CPU only when it finishes with its current burst.
Non-preemptive would not likely be used in a computer centre, especially in a time sharing system, because it cannot guarantee that each user gets a share of the CPU at regular intervals. Non-preemptiveness allows programs to run infinitely long thus making turnaround time (response time) for other submitted jobs even longer.
Round-Robin is a preemptive scheme that makes use of interrupt/context switching operation to allow processor switching between jobs. Long jobs cannot delay shorter ones, because short jobs are guaranteed of getting the processor periodically. Interactive users will thus receive the processor frequently enough to maintain good response times.
Q2 Explain the difference in degree to which the following scheduling algorithms discriminate in favour of short jobs.(i) First Come, First Served(ii) Round Robin(iii) Multi-level feedback queues
(i) First Come, First Served (FCFS) - discriminates against short jobs since any short jobs arriving after long jobs will have a long waiting time.
(ii) Round-Robin - treats all jobs equally (giving them equal bursts of CPU time) so short jobs will be able to leave the system faster since they will finish first.
(iii) Multi-Level Feedback Queues - discriminate very favourably toward short jobs since it works similar to the round robin algorithm.
Q3 What effect does the size of time quantum have on the performance of a round robin (RR) algorithm?
At one extreme, if the time quantum is extremely large, the RR policy is the same as the FCFS policy. If the time quantum is small, it must be large with respect to context switch, otherwise overhead is too high.
Q4 What advantage is there in having different quantum sizes on different levels of a multi-level feedback queuing system ?
The advantage is that the short jobs will have highest priority if they are shorter than the initial quantum. This serves them fast and frees the CPU to concentrate on longer jobs.
The jobs that are pushed to the next level (lower priority), now can be given more time than the initial quantum since the goal is to run as many programs as fast as possible with minimal delays to other programs.
Therefore, by increasing the quantum with the level, shorter jobs will be allowed higher priority, and longer jobs will be allowed to run simultaneously with minimum delays.
星期一, 10月 12, 2009
CS3161 (A) OPERATING SYSTEM PRINCIPLES (DR. LIU WENYIN) (09CS3161_LW) - Answers to Tutorial 4 Questions
Q1 List the four major categories of the benefits of multithreaded programming. Briefly explain each.
The benefits of multithreaded programming fall into the categories: responsiveness, resource sharing, economy, and utilization of multiprocessor architectures.
Responsiveness means that a multithreaded program can allow a program to run even if part of it is blocked. Resource sharing occurs when an application has several different threads of activity within the same address space. Threads share the resources of the process to which they belong. As a result, it is more economical to create new threads than new processes. Finally, a single threaded process can only execute on one processor regardless of the number of processors actually present. Multiple threads can run on multiple processors, thereby increasing efficiency.
Q2 What resources are used when a thread is created ?
How do they differ from those used when a process is created ?
Thread context must be created, including a register set, location for storage during a context switching and a local stack to record the procedure call arguments, return values and return addresses and thread local storage.
Code and data are shared with parent process or parent thread (no loading or allocation of memory necessary).
Process creation similar to thread storage (as above), with extra storage for program instructions and data.
Codes and data may be loaded for every process into the allocated memory and no sharing with other processes.
Q3 What is a thread pool and why is it used?
A thread pool is a collection of threads, created at process startup, that sit and wait for work to be allocated to them. This allows one to place a bound on the number of concurrent threads associated with a process and reduce the overhead of creating new threads and destroying them at termination.
Q4 What are the differences between user-level threads and kernel-support threads ?
User-levels thread have no kernel support, so they are very inexpensive (in terms of resources demand) to create, destroy, and switch among threads do not cause interrupt to CPU.
Kernel support thread are more expensive (in resources) because system calls are needed to create and destroy them and the kernel must schedule them to share access to CPU. They are more powerful because they are independently scheduled and block individually.
The benefits of multithreaded programming fall into the categories: responsiveness, resource sharing, economy, and utilization of multiprocessor architectures.
Responsiveness means that a multithreaded program can allow a program to run even if part of it is blocked. Resource sharing occurs when an application has several different threads of activity within the same address space. Threads share the resources of the process to which they belong. As a result, it is more economical to create new threads than new processes. Finally, a single threaded process can only execute on one processor regardless of the number of processors actually present. Multiple threads can run on multiple processors, thereby increasing efficiency.
Q2 What resources are used when a thread is created ?
How do they differ from those used when a process is created ?
Thread context must be created, including a register set, location for storage during a context switching and a local stack to record the procedure call arguments, return values and return addresses and thread local storage.
Code and data are shared with parent process or parent thread (no loading or allocation of memory necessary).
Process creation similar to thread storage (as above), with extra storage for program instructions and data.
Codes and data may be loaded for every process into the allocated memory and no sharing with other processes.
Q3 What is a thread pool and why is it used?
A thread pool is a collection of threads, created at process startup, that sit and wait for work to be allocated to them. This allows one to place a bound on the number of concurrent threads associated with a process and reduce the overhead of creating new threads and destroying them at termination.
Q4 What are the differences between user-level threads and kernel-support threads ?
User-levels thread have no kernel support, so they are very inexpensive (in terms of resources demand) to create, destroy, and switch among threads do not cause interrupt to CPU.
Kernel support thread are more expensive (in resources) because system calls are needed to create and destroy them and the kernel must schedule them to share access to CPU. They are more powerful because they are independently scheduled and block individually.
星期四, 10月 08, 2009
CS3161 (A) OPERATING SYSTEM PRINCIPLES (DR. LIU WENYIN) (09CS3161_LW) - Answers to Tutorial 3 Questions
Q1 What is PCB? What information are usually stored in PCB?
PCB Stands for Process Control Block.
Process State
Program Counter
CPU Registers
CPU Scheduling information
Memory management information
I/O Status
Accounting information
Q2 Explain the concept of a context switch.
Whenever the CPU starts executing a new process, the old process's state must be preserved. The context of a process is represented by its process control block. Switching the CPU to another process requires performing a state save of the current process and a state restore of a different process. This task is known as a context switch. When a context switch occurs, the kernel saves the context of the old process in its PCB and loads the context of the new process scheduled to run.
Q3 Explain the main differences between a short-term and long-term scheduler.
The primary distinction between the two schedulers lies in the frequency of execution. The short-term scheduler is designed to frequently select a new process for the CPU, at least once every 100 milliseconds. Because of the short time between executions, the short-term scheduler must be fast. The long-term scheduler executes much less frequently; minutes may separate the creation of one new process and the next. The long-term scheduler controls the degree of multiprogramming. Because of the longer interval between executions, the long-term scheduler can afford to take more time to decide which process should be selected for execution.
Q4 We can describe much of processor management in terms of process state transition diagrams, such as:
Run 2 1 3 4 Wait Ready (Blocked)
(i) Give one example of "event" that causes each of the mark transitions ?
(ii) When we view all the processes in the system, we can see that a state transition by one process could cause another process to make a state transition also. Under what circumstances could transition 3 by one process immediately cause transition 1 by another process ? List all similar situations.
Q4 Process State Transitions
(i) Transition 1 - Last process completed or blocked, another process on the ready queue will be allocated the CPU for execution (Dispatch).
Transition 2 - Preemptive scheduling system
Transition 3 - Process requests an I/O operation
Transition 4 - I/O device completion, process joins the ready queue.
(ii) Process Transitions :
Process request I/O operation - When a process make an I/O service request (Transition 3), when the I/O device is not available at that time, it will go through a transition from run state to wait (blocked) state. At the same time another process on the ready queue will be allocated the CPU for execution (Transition 1) during that time.
Process exceeded the CPU allowance, completed execution or abortion in error condition (Transition 2), another process dispatch to use the CPU (Transition 1).
PCB Stands for Process Control Block.
Process State
Program Counter
CPU Registers
CPU Scheduling information
Memory management information
I/O Status
Accounting information
Q2 Explain the concept of a context switch.
Whenever the CPU starts executing a new process, the old process's state must be preserved. The context of a process is represented by its process control block. Switching the CPU to another process requires performing a state save of the current process and a state restore of a different process. This task is known as a context switch. When a context switch occurs, the kernel saves the context of the old process in its PCB and loads the context of the new process scheduled to run.
Q3 Explain the main differences between a short-term and long-term scheduler.
The primary distinction between the two schedulers lies in the frequency of execution. The short-term scheduler is designed to frequently select a new process for the CPU, at least once every 100 milliseconds. Because of the short time between executions, the short-term scheduler must be fast. The long-term scheduler executes much less frequently; minutes may separate the creation of one new process and the next. The long-term scheduler controls the degree of multiprogramming. Because of the longer interval between executions, the long-term scheduler can afford to take more time to decide which process should be selected for execution.
Q4 We can describe much of processor management in terms of process state transition diagrams, such as:
Run 2 1 3 4 Wait Ready (Blocked)
(i) Give one example of "event" that causes each of the mark transitions ?
(ii) When we view all the processes in the system, we can see that a state transition by one process could cause another process to make a state transition also. Under what circumstances could transition 3 by one process immediately cause transition 1 by another process ? List all similar situations.
Q4 Process State Transitions
(i) Transition 1 - Last process completed or blocked, another process on the ready queue will be allocated the CPU for execution (Dispatch).
Transition 2 - Preemptive scheduling system
Transition 3 - Process requests an I/O operation
Transition 4 - I/O device completion, process joins the ready queue.
(ii) Process Transitions :
Process request I/O operation - When a process make an I/O service request (Transition 3), when the I/O device is not available at that time, it will go through a transition from run state to wait (blocked) state. At the same time another process on the ready queue will be allocated the CPU for execution (Transition 1) during that time.
Process exceeded the CPU allowance, completed execution or abortion in error condition (Transition 2), another process dispatch to use the CPU (Transition 1).
星期三, 10月 07, 2009
朗文電子課本 msvcr80.dll error
為何我的電子書在裝有 Microsoft Window Vista 或 Microsoft Office 2007 的電腦上運行不到？
由於 Microsoft Window Vista 和 Microsoft Office 2007 上有一個 dll 檔案和電子書有所衝突以致未能運作。解決方法如下：
1. 在你的硬碟〈例如：C drive〉上建立一個資料夾〈例如：ebook，不可以是中文名稱〉。
2. 把電子書光碟的所有檔案複製到新建立的資料夾〈例如：C:\ebook〉。
3. 到下列網址下載一個名為 2006_eBook_Update.zip 的檔案。
http://www.ilongman.com/temp/2006_eBook_Update.zip
4. 將上述檔案解壓於桌面，桌面上將會出現兩個檔案 〈shell.exe, main.exe〉。
5. 將上述兩個檔案複製到硬碟上的電子書 program 資料夾內〈例如：C\ebook\program〉，確定取代舊有的兩個檔案。
6. 啟動電子書資料夾內的 startcd.exe。
由於 Microsoft Window Vista 和 Microsoft Office 2007 上有一個 dll 檔案和電子書有所衝突以致未能運作。解決方法如下：
1. 在你的硬碟〈例如：C drive〉上建立一個資料夾〈例如：ebook，不可以是中文名稱〉。
2. 把電子書光碟的所有檔案複製到新建立的資料夾〈例如：C:\ebook〉。
3. 到下列網址下載一個名為 2006_eBook_Update.zip 的檔案。
http://www.ilongman.com/temp/2006_eBook_Update.zip
4. 將上述檔案解壓於桌面，桌面上將會出現兩個檔案 〈shell.exe, main.exe〉。
5. 將上述兩個檔案複製到硬碟上的電子書 program 資料夾內〈例如：C\ebook\program〉，確定取代舊有的兩個檔案。
6. 啟動電子書資料夾內的 startcd.exe。
星期六, 10月 03, 2009
開心水族館養扇貝虧錢
養扇貝是一種浪費錢的舉動.....
不但虧錢, 連經驗值都不會給
算式如下:
扇貝一個1.2w，假若每次10小時都準時收成，那麼…
24h(天) x 15天(使用期限) = 360(H)
360(H) / 10(H) = 36顆
36顆 x 200元 = 7200元
12000-7200=4800(虧損)
不但虧錢, 連經驗值都不會給
算式如下:
扇貝一個1.2w，假若每次10小時都準時收成，那麼…
24h(天) x 15天(使用期限) = 360(H)
360(H) / 10(H) = 36顆
36顆 x 200元 = 7200元
12000-7200=4800(虧損)