Concurrency 2010

29
Concurrency 林林林 , 林林林 林林林林 2010/11

description

SystemC Concurrency : sc_event how to do?

Transcript of Concurrency 2010

Page 1: Concurrency 2010

Concurrency

林敬倫 , 蘇文鈺成大資訊2010/11

Page 2: Concurrency 2010

Why Concurrency?

• Real-Life system is concurrent• Machines work concurrently• Circuits work concurrently• Software processes execute concurrently. Here, events

are usually used to handle concurrency problems.• So, we use concurrent processes to model a system.• Therefore, the simulation kernel has to handle the

execution of concurrent processes.• In SystemC, thread and method are two main process

types.

Page 3: Concurrency 2010

sc_event• An event happens at a specific time instant and carries no value

and duration. So, when it occurs, no trace of its occurrence can be located except the effects it causes.

• SystemC simulation kernel is an event-driven simulator.• SystemC uses sc_event which is responsible for launching and

triggering of events.• sc_event happens at a single point of time.• To observe an event, there must be processes waiting for it and

firing actions for it such that we know its occurrence.• you can perform only two actions with an sc_event: wait for it or

cause it to occur.• Syntax: sc_event name_of_event, …;• A scheduled event can be cancelled by name_of_event.cancel();

Page 4: Concurrency 2010

Simplified Simulation Kernel

[From SystemC From the Groud Up]

Page 5: Concurrency 2010

How SystemC simulation Kernel Works

• Process is ready for execution when the events it waits are triggered.

• Processes waits for a certain time period to return to their execution.

• This period can be zero delay or a certain amount of cycles. If zero delay, they are ready for execution. Otherwise, they will be placed in waiting list until the amount of cycles passes.

Page 6: Concurrency 2010

Process execution and Event Pools

[From SystemC From the Groud Up]

Page 7: Concurrency 2010

More on Kernel Operation

• SystemC kernel enters the waiting state whenever it encounters an explicit wait(), or in some cases performs a return.– For zero delay, it is called a delta cycle delay.

Related processes are moved to ready list.– For non-zero delay, processes are moved to the

ready list when the time is advanced to the scheduled time is met.

– When no process is to be executed for a triggered event, it simply returns to sc_main and finished.

Page 8: Concurrency 2010

Use SC_THREAD as Process

• An SC_THREAD is started once and only once.• An sc_thread takes control when it is started and

returns (wait() inside of a loop) to the kernel or simply exits (return) after its execution.

• When a SC_THREAD exits, it terminates forever, so, SC_THREAD usually contains an infinite loop.(while(1);) and at least one wait().

• An indirect method to invoke wait() is to call blocking methods like sc_fifo read or write.

Page 9: Concurrency 2010

Trigger of an Event using .notify()

• To cause an event to occur, .notify() can be used.• Usages:

– name_of_event .notify(); //immediate notification– name_of_event .notify(SC_ZERO_TIME);//delayed notification– name_of_event .notify(time);//timed notification– notify(name_of_event)– notify(name_of_event, SC_ZERO_TIME);– notify(name_of_event, time);

• Events can be cancelled by using .cancel(), but immediate events, which happen at the present notification time, cannot be cancelled.

Page 10: Concurrency 2010

Effects of notify

• When using notify(), kernel moves processes waiting for the from the wait pool into the ready list.

• Notified Processes will execute only after all waiting processes have executed.

• An sc_event may have no more than a single outstanding scheduled event, and only the nearest time notification is allowed.

Page 11: Concurrency 2010

Dynamic Sensitivity of sc_thread using wait()

• Wait() is used to suspend an sc_thread.• When wait() is executed, the state of the

current sc_thread is saved and SystemC simulation kernel takes back its control.

• Then, the kernel tries to activate the next ready process.

• When the suspended thread resumes, its saved context is restored before continuing its execution.

Page 12: Concurrency 2010

Syntax of wait()

• wait(time);• wait(name_of_event);• wait(name_of_event1&name_of_event2&…);• wait(timeout, name_of_event);• wait(timeout, name_of_event1 |

name_of_event2 | …….);• wait();// static sensitivity• …. And so on.

Page 13: Concurrency 2010

Time_out()

• Use time_out() to test a system

sc_event event1, event2;….wait(time, event1|event2);If(time_out()) break;….If(event2) printf(…..);…….

Page 14: Concurrency 2010

Simulation Scenarios in Different Perspects

User Perceives

Actual in SystemC Kernel

[From SystemC From the Groud Up]

Page 15: Concurrency 2010

Use SC_METHOD as Process

• It is like a function call in C. Therefore, it is less suitable to modeling some behavior.

• It runs completely and returns and may not suspend internally. Thus, wait() cannot be used here.

• Based one sensitivity, it is called repeated by the simulation kernel. Therefore, it is more like Verilog always@() statement.

• There are also implied waits such as read/write of sc_fifo, which should be avoided in sc_method.

Page 16: Concurrency 2010

Using SC_METHOD and its Sensitivity

• Syntax:– SC_METHOD(name_of_process);

• Using an SC_METHOD, variables must be declared and initialized each time when it is invoked.

• Sensitivity: the way it can be called repeatedly and synchronized with other processes– Dynamic– Static

Page 17: Concurrency 2010

Dynamic Sensitivity of SC_METHOD

• next_trigger()– next_trigger(time);– next_trigger(event);– next_trigger(name_of_event1&name_of_event2&…);– next_trigger(timeout, name_of_event);– next_trigger(timeout, name_of_event1 | name_of_event2 |

…….);– next_trigger();// static sensitivity– …. And so on.

• Looks exactly the same as wait();

Page 18: Concurrency 2010

Using next_trigger()

• It should be initialized and executed before the return of this SC_METHOD.

• It is important to apply next_trigger() at every exit path in a SC_METHOD. Otherwise, it will never be invoked again.

• To avoid the situation that a method is never called again, one can place a default next_trigger as its first statement.

• It can be repeatedly called. Each time it is called, the previous ones are override.

Page 19: Concurrency 2010

Processing Order of wait() and next_trigger()

• wait(name_of_event1&name_of_event2&…)/next_trigger(name_of_event1&name_of_event2&…);– There is no knowing which event comes first:

name_of_event1 or name_of_event2. It can be asserted that both events happen.

• wait(name_of_event1|name_of_event2&…)/next_trigger(name_of_event1|name_of_event2&…);– It can be asserted that either events or both events

happen. To know which event happen, additional code is required, like the time_out() example.

Page 20: Concurrency 2010

Static Sensitivity

• Static sensitivity is established during the elaboration stage and cannot be changed once it is established.

• It applies to the most recent process registration. It is used when processes are handled for certain fixed events without implementing the related codes in the processes bodies.

• Thread: wait();// static sensitivity• Method: next_trigger();// static sensitivity• Syntax:

– sensitive << name_of_event1 [<< name_of_event2];– sensitive (name_of_event, …);

Page 21: Concurrency 2010

Example:using event & next_trigger

• Hello_module:– Thread1:執行五次後會對 thread2發出通知 ,執行八次後會對method發出通知並將記數器歸零 .

– Thread2:執行兩次後會等待 thread1的通知再繼續進行 ;執行三次後會對method發出通知並將記數器歸零 .

– Method:等待 thread1及 thread2的通知 ,並在thread2通知執行過後 ,將只接受 thread1的通知 (即 thread2的通知將被忽略 ).

Page 22: Concurrency 2010

Main.cpp#include <systemc.h>#include "hello_module.h"int sc_main(int argc, char* argv[]){

// signal declarationsc_clock clk("clk", 10, SC_NS, 0.5);

// module declarationhello_module module0("hello_word");

// signal connectionmodule0.clk(clk);

// run simulationsc_start(1000, SC_NS);

return 0;}

Page 23: Concurrency 2010

Hello_module.h#include <systemc.h>

SC_MODULE(hello_module){

// signal declarationsc_in_clk clk;

// fuction declarationvoid thread_func1();void thread_func2();void method_func();

//Constructor SC_CTOR(hello_module) {

count1 = 0;count2 = 0;

SC_THREAD(thread_func1);sensitive << clk.pos();

SC_THREAD(thread_func2);sensitive << clk.pos();

SC_METHOD(method_func);sensitive << T1toM;sensitive << T2toM;

}//event declarationsc_event T1toT2, T1toM, T2toM;

int count1, count2;};

Page 24: Concurrency 2010

Hello_moule.cpp(1/3)#include "hello_module.h"

void hello_module::thread_func1(){

while(1){wait();count1++;

sc_time_stamp().print();printf(" Thread1 : \n");

if(count1 == 5){printf(" Thread1 : T1toT2.notify() \n");T1toT2.notify();

}if(count1 == 8){

printf(" Thread1 : T1toM.notify() \n");T1toM.notify();count1 = 0;

}}}

Page 25: Concurrency 2010

Hello_moule.cpp(2/3)void hello_module::thread_func2(){

while(1){wait();count2++;

sc_time_stamp().print();printf(" Thread2 : \n");if(count2 == 2){

printf(" Thread2 : wait for T1.notify1 \n");wait(T1toT2);

}if(count2 == 3){

printf(" Thread2 : T2toM.notify() \n");T2toM.notify();count2 = 0;

}}

}

Page 26: Concurrency 2010

Hello_moule.cpp(3/3)

void hello_module::method_func(){

if(clk){sc_time_stamp().print();printf(" Method : Hello Word! \n");//當 T2toM叫起methodu第一次之後 ,T2toM將會失去作用 . next_trigger(T1toM);

}}

Page 27: Concurrency 2010

Be Careful of Processing Order

• One must be sure of the processing order of processes, because different processor orders may cause different results.

• Sometimes, wrong process order may cause simulation errors though the program can be successfully compiled and no runtime error.

• 書中 figure 7-16 to 7-19舉了一個例子 . 請大家看一下 , 然後寫一個簡單的例子 , 當沒有figure7-17中的 wait(SC_ZERO_TIME)時 , simulation結果會有何不同呢 ?

Page 28: Concurrency 2010

上一頁裡提出的問題• 若沒有 wait(SC_ZERO_TIME),則無法確定

turn_knob_thread()會在 stop_signal_thread()執行後才執行 ,若是 turn_knob_thread()先執行 ,所做出 event.notify()的動作將會因為stop_signal_thread()之中的 event尚未執行wait(event)因此出現模擬錯誤 .

• 因此需要 wait(SC_ZERO_TIME)將turn_knob_thread()放置整個 cycle最後才執行 ,否則執行結果將不是正確的模擬結果 .

Page 29: Concurrency 2010

HW3• 請設計以下四個模組 :

– 模組一 : 系統一開始時讀入一文字檔 (純英文 ),並讀入要搜尋的兩個關鍵字。

– 模組二 : 每個時脈時自模組一接收一個word,遇標點符號時丟棄之。– 模組三 : 每當模組二接到一個非標點符號的word時,自模組二接收此一

word,並檢查是否為第一個關鍵字,若是,則計數器加一。– 模組四 : 每當模組二接到一個非標點符號的word時,自模組二接收此一

word,並檢查是否為第二個關鍵字,若是,則計數器加一。– 文件結束時,模組三與模組數四通知模組一其個別之數目,模組一印出數目後,讀入新的檔案。此處理直到該目錄下之檔案均被檢查完後結束。

• 模組中必須含有method與 thread,其他你可能需要再設計其他模組來進行四個模組的控制,此一模組之設計則無限制。

• 模組間之資料傳輸此次不限定要用 SystemC的預設介面• 請用OpenESL作此一作業。 2010/12/9, 11:59PM繳交。