Concurrency 2010
Download as PPTX, PDF2 likes824 views
This document discusses concurrency in SystemC simulations. It explains that SystemC uses events and processes to model concurrent systems. There are two main types of processes: threads and methods. Threads can wait for events using wait() and methods use next_trigger() to establish dynamic sensitivity. Events have no duration and are used to trigger processes. Notifying an event using notify() moves waiting processes to the ready queue. The SystemC kernel is event-driven and executes ready processes in non-deterministic order.
![Simplified Simulation Kernel
[From SystemC From the Groud Up]](https://image.slidesharecdn.com/concurrency2010-131015115322-phpapp01/85/Concurrency-2010-4-320.jpg)
![Process execution and Event Pools
[From SystemC From the Groud Up]](https://image.slidesharecdn.com/concurrency2010-131015115322-phpapp01/85/Concurrency-2010-6-320.jpg)
![Simulation Scenarios in Different
Perspects
User Perceives
Actual in SystemC Kernel
[From SystemC From the Groud Up]](https://image.slidesharecdn.com/concurrency2010-131015115322-phpapp01/85/Concurrency-2010-14-320.jpg)
![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, …);](https://image.slidesharecdn.com/concurrency2010-131015115322-phpapp01/85/Concurrency-2010-20-320.jpg)
![Main.cpp
#include <systemc.h>
#include "hello_module.h"
int sc_main(int argc, char* argv[])
{
// signal declaration
sc_clock
clk("clk", 10, SC_NS, 0.5);
// module declaration
hello_module
module0("hello_word");
// signal connection
module0.clk(clk);
// run simulation
sc_start(1000, SC_NS);
return 0;
}](https://image.slidesharecdn.com/concurrency2010-131015115322-phpapp01/85/Concurrency-2010-22-320.jpg)
Concurrency 2010
- 2. 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.
- 3. 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();
- 4. Simplified Simulation Kernel [From SystemC From the Groud Up]
- 5. 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.
- 6. Process execution and Event Pools [From SystemC From the Groud Up]
- 7. 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.
- 8. 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.
- 9. 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.
- 10. 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.
- 11. 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.
- 12. 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.
- 13. Time_out() • Use time_out() to test a system sc_event event1, event2; …. wait(time, event1|event2); If(time_out()) break; …. If(event2) printf(…..); …….
- 14. Simulation Scenarios in Different Perspects User Perceives Actual in SystemC Kernel [From SystemC From the Groud Up]
- 15. 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.
- 16. 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
- 17. 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();
- 18. 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.
- 19. Processing Order of wait() and next_trigger() • wait(name_of_event1&name_of_event2&…)/nex t_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.
- 20. 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, …);
- 21. Example:using event & next_trigger • Hello_module: – Thread1:執行五次後會對thread2發出通知,執行 八次後會對method發出通知並將記數器歸零. – Thread2:執行兩次後會等待thread1的通知再繼 續進行;執行三次後會對method發出通知並將記 數器歸零. – Method:等待thread1及thread2的通知,並在 thread2通知執行過後,將只接受thread1的通知 (即thread2的通知將被忽略).
- 22. Main.cpp #include <systemc.h> #include "hello_module.h" int sc_main(int argc, char* argv[]) { // signal declaration sc_clock clk("clk", 10, SC_NS, 0.5); // module declaration hello_module module0("hello_word"); // signal connection module0.clk(clk); // run simulation sc_start(1000, SC_NS); return 0; }
- 23. Hello_module.h //Constructor SC_CTOR(hello_module) { count1 = 0; count2 = 0; #include <systemc.h> SC_MODULE(hello_module) { // signal declaration sc_in_clk clk; SC_THREAD(thread_func1); sensitive << clk.pos(); // fuction declaration void thread_func1(); void thread_func2(); void method_func(); SC_METHOD(method_func); sensitive << T1toM; sensitive << T2toM; SC_THREAD(thread_func2); sensitive << clk.pos(); } //event declaration sc_event T1toT2, T1toM, T2toM; int count1, count2; };
- 24. 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; }}}
- 25. 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; } } }
- 26. 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); } }
- 27. 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結果會 有何不同呢?
- 29. HW3 • 請設計以下四個模組: – 模組一: 系統一開始時讀入一文字檔(純英文)，並讀入要搜尋的兩 個關鍵字。 – 模組二: 每個時脈時自模組一接收一個word，遇標點符號時丟棄 之。 – 模組三: 每當模組二接到一個非標點符號的word時，自模組二接收 此一word，並檢查是否為第一個關鍵字，若是，則計數器加一。 – 模組四: 每當模組二接到一個非標點符號的word時，自模組二接收 此一word，並檢查是否為第二個關鍵字，若是，則計數器加一。 – 文件結束時，模組三與模組數四通知模組一其個別之數目，模組 一印出數目後，讀入新的檔案。此處理直到該目錄下之檔案均被 檢查完後結束。 • 模組中必須含有method與thread，其他你可能需要再設計其他 模組來進行四個模組的控制，此一模組之設計則無限制。 • 模組間之資料傳輸此次不限定要用SystemC的預設介面 • 請用OpenESL作此一作業。2010/12/9，11:59PM繳交。