Music & Video

[1] D. Abraham, H. D. Patel, and S. K. Shukla, A Multi-MOC Framework for SOC Modeling using SML, FERMAT Lab Tech Report , PDF

References [1] D. Abraham, H. D. Patel, and S. K. Shukla, A Multi-MOC Framework for SOC Modeling using SML, FERMAT Lab Tech Report , [2] Eklectic Ally, Simulation Engine Example, Website:
of 17
All materials on our website are shared by users. If you have any questions about copyright issues, please report us to resolve them. We are always happy to assist you.
Related Documents
References [1] D. Abraham, H. D. Patel, and S. K. Shukla, A Multi-MOC Framework for SOC Modeling using SML, FERMAT Lab Tech Report , [2] Eklectic Ally, Simulation Engine Example, Website: [3] J. Armstrong, Ptolemy Eye Model, Website: pushkin/ece6444/presentation armstrong.pdf. [4] D. Berner, S. Suhaib, S. Shukla, and H. Foster, XFM: Extreme Formal Method for Capturing Formal Specification into Abstract Models, Tech. Report , Virginia Tech, [5] S. Bhattacharyya, P. Murthy, and E. Lee, Software Synthesis from Dataflow Graphs, Kluwer Academic Publishers, [6] Shuvra S. Bhattacharyya, Elaine Cheong, John Davis II, Mudit Goel, Christopher Hylands, Bart Kienhuis, Edward A. Lee, Jie Liu, Xiaojun Liu, Lukito Muliadi, Steve Neuendorffer, John Reekie, Neil Smyth, Jeff Tsay, Brian Vogel, Winthrop Williams, Yuhong Xiong, Yang Zhao, and Haiyang Zheng, Heterogenous Concurrent Modelling and Design in Java: Volume 2 - Ptolemy II Software Architecture, Memorandum UCB/ERL M03/28, July [7] S. Borkar, Design challenges of technology scaling, InIEEEMicro19 (1999), [8] N. Chomsky, Three models for the description of language, IRE Transaction on Information Theory 2 (1956), no. 3, [9] A. Church, The calculi of lamdba conversion, Princeton University Press, [10] E. Clarke, O. Grumberg, and D. Peled, Model Checking, The MIT Press, [11] M. Clausen and A. Fortenbacher, Efficient solution of linear Diophantine equations, Journal of Symbolic Computation 8 (1989), no. 1-2, [12] National Research Council, Embedded Everywhere, National Academy Press, 2001. 156 [13] CPPreference, Cppreference, Website: htpp:// [14] F. Doucet, R. Gupta, M. Otsuka, P. Schaumont, and S. Shukla, Interoperability as a design issue in c++ based modeling environments, Proceedings of the 14th international symposium on Systems synthesis, [15] A. Jantsch et al., The ForSyDe Project, Website: [16] International Technology Roadmap for Semiconductors, Website: [17] FORTE, Forte Design Systems, Website: [18] A. Fortenbacher, Algebraische unifikation, Master s thesis, Universitat Karlsruhe, [19] E. Gamma, R. Helm, R. Johnson, and J. Vlissides, Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, October [20] P. Garg, S. K. Shukla, and R. K. Gupta, Efficient Usage of Concurrency Models in an Object-Oriented Co-design Framework, In Proceedings of DATE 01, [21] GNU, Autoconf, Website: [22], Automake, Website: [23] T. Grotker, S. Liao, G. Martin, and S. Swan, System Design with SystemC, Kluwer Academic Publishers, [24] Ptolemy Group, HTVQ Block Diagram, Website: [25], Ptolemy II, Website: [26] T. Guckenbiehl and A. Herold, Solving Linear Diophantine Equations, Tech. Report SEKI-85-IV-KL, Universitat Kaiserslautern, [27] C. Hoare, Communicating Sequential Processes, Communications of the ACM, 21, vol. 8, ACM Press, 1978, pp [28] C. A. R. Hoare, Communicating Sequential Processes, Prentice Hall, [29] J. E. Hopcroft and J. D. Ullman, Introduction to Automata Theory, Languages, and Computation, Addison-Wesley, [30] G. Huet, An algorithm to generate the basis of solutions to homogeneous linear Diophantine equations, Information Processing Letters, April 1978, 7(3). [31] J. Jájá, Introduction to Parallel Algorithms, Addison-Wesley, [32] A. Jantsch, Modeling Embedded Systems And SOC s - Concurrency and Time in Models of Computations, Morgan Kaufmann Publishers, 2003. REFERENCES 157 [33] J.Walker, The Analytical Engine: The First Computer, Website: [34] G. Kahn, Coroutines and networks of parallel processes, Information Processing, North-Holland Publishing Company, [35] David Keppel, Tools and Techniques for Building Fast Portable Threads Packages, Tech. Report UWCSE , University of Washington Department of Computer Science and Engineering, May [36] FERMAT Research Lab., SystemC-H Website, Website: [37] L. Lavagno, A. Sangiovanni-Vincentelli, and E. Sentovich, Models of Computation for Embedded System Design, Website:, [38] E. A. Lee and D. G. Messerschmitt, Static Scheduling of Synchronous Data Flow Programs for Digital Signal Processing, In Proceedings of IEEE Transactions on Computers, NO. 1, vol. Vol. C-36, [39] Edward A. Lee and Alberto L. Sangiovanni-Vincentelli, Comparing Models of Computation, In Proceedings of the International Conference on Computer- Aided Design (ICCAD), IEEE Computer Society, 1996, pp [40] Formal Systems (Europe) Ltd., The FDR Model Checker, Website:, [41] A. Michalove, Amdahl s Law, Website: whaleyt/classes/parallel/topics/amdahl.html. [42] MicroLib, PowerPC 750 Simulator, Website: [43] R. Milner, Communication and concurrency, Prentice Hall, [44] Gordon Moore, Cramming more Components onto Integrated Circuits, 38 (1965), no. 8. [45] B. Niemann, F. Mayer, F. Javier, R. Rubio, and M. Speitel, Refining a High Level SystemC Model, Kluwer Academic Publishers, 2003, In SystemC: Methodologies and Applications, Ed. W. Muller and W. Rosenstiel and J. Ruf. [46] NS-2, Network Simulator 2, Website: [47] Sobel operator, Sobel Operator Algorithm, Website: 00.pdf. [48] OPNET, OPNET, Website: [49] OSCI, SystemC, Website: [50] C. H. Papadimitriou, Computational complexity, Addison-Wesley, 1994. 158 [51] D. Pasechnik, Linear Diophantine Equation Solver, Website: dima/software.html. [52] H. D. Patel, HEMLOCK: HEterogeneous ModeL Of Computation Kernel for SystemC, Master s thesis, Virginia Polytechnic Institute and State University, December 2003, Website: [53] H. D. Patel and S. K. Shukla, Towards A Heterogeneous Simulation Kernel for System Level Models: A SystemC Kernel for Synchronous Data Flow Models, Tech. Report , FERMAT Lab Virginia Tech., [54], Towards A Heterogeneous Simulation Kernel for System Level Models: A SystemC Kernel for Synchronous Data Flow Models, Proceedings of International Symposium in VLSI, IEEE Computer Society Press, [55], Towards A Heterogeneous Simulation Kernel for System Level Models: A SystemC Kernel for Synchronous Data Flow Models, Proceedings of Great Lakes Symposium in VLSI, [56], Truly Heterogeneous Modeling with SystemC, ch. Formal Models and Methods for System Design, Kluwer Academic Publishers, The Netherlands, [57] B. Pierce, Types and Programming Languages, MIT Press, [58] M. O. Rabin and D. Scott, Finite Automata and Their Decision Problems, IBM Journal of Research 3 (1959), no. 2, [59] D. Sangiorgi and D. Walker, The pi-calculus: A theory of mobile processes, Cambridge University Press, [60] J. R. Senning, Solution of the Dining Philosophers Problem using Shared Memory and Semaphores, Website: [61] S. Sharad, D. Bhaduri, M. Chandra, H. Patel, and S. Syed, Systematic Abstraction of Microprocessor RTL models to enhance Simulation Efficiency, In Proceedings of Microprocessor Test and Verification 2003, [62] S. Sharad and S. K. Shukla, Efficient Simulation of System Level Models via Bisimulation Preserving Transformations, Tech. report, FERMAT Lab Virginia Tech., [63] SPECC, SpecC, Website: [64] Synopsys, Synopsys, Website: [65] SystemVerilog, System Verilog, Website: [66] A. M. Turing, On computable numbers with an application to the entscheidungs problem, Proceedings of London Mathematical Society 2 (1936), no. 42, [67] V. A. Uspensky, Post s machine, Firebird Publications, Inc., [68] VERILOG, Verilog, Website: REFERENCES 159 [69] VHDL, VHDL, Website: [70] M. H. Weik, The ENIAC Story, Website: mike/comphist/eniac-story.html, 1961. Appendix A QuickThreads in SystemC Extension of SystemC for hierarchy and heterogeneity necessitates the understanding of QuickThread packaging and implementation before alteration. Unfortunately, the existing SystemC source does not provide much internal documentation to assist kernel experimenters with a better understanding of SystemC s QuickThread implementation. In this section, we explain the QuickThread implementation such that motivated kernel developers for SystemC can quickly comprehend the specifics. We discuss QuickThreads in general and urge readers to refer to [35]. We continue by describing how threads in SystemC employ the QuickThread client package and how it enforces certain syntax requirements. We expect the reader to be familiar with basic SystemC constructs. 1. QuickThreads QuickThread (QT) is a package core and not a standalone thread package by itself. The difference is that a package core only provides an interface to create machine dependent code for easier portability, whereas a standalone thread package provides the user with full implementation of stack space, thread synchronization and sometimes even scheduling. Instead, QuickThread allows users to construct non-preemptive thread packages. The goals of the QuickThread core package are as follows: To provide an easy API to construct user-level thread packages. These user thread packages can be seamlessly ported to architectures supported by QuickThread. To separate execution of threads from their allocation and scheduling. Synchronization of threads for uni and multi processors has problems of its own such as race conditions, violation of stack space access, need for locking, mutexes, extra context switches and so on. We do not discuss these issues here since our focus is in gaining some basic level understanding of QuickThreads and their implementation with SystemC. The QT package uses preswitch as its synchronization mechanism. This mechanism functions in the following manner: 1 Block the current executing thread. 2 Switch to the new thread s stack and execute some clean-up code for the old thread. 162 The immediate disadvantage of this approach is that a thread cannot context switch to itself, because the preswitch synchronization requires a new thread to execute some clean-up code on the old thread. Hence, a new thread must execute for the old thread to be completely switched out. Furthermore, QuickThread does not implement any locking, making the users implement a locking mechanism. The user packaging of QuickThread will be referred to as the client package [35]. A QuickThread can have several states that distinguish the modes of the thread during its lifetime and they are as follows: Uninitialized: A thread that requires stack allocation to be performed. Initialized: Stack allocation is performed on the thread and a function and its arguments are initialized on the stack region. Ready-to-run: Once initialized, the thread is ready-to-run. This is the same as a thread that is Blocked. Running: The thread scheduled on the processor for execution. Blocked: The suspended thread. A thread is created when the client code allocates stack space for the particular thread. The stack can either grow upwards or downwards depending on the machine architecture, which has to be handled by the client package. The client thread allocation routine passes in the address and size of the stack space to a QuickThread routine that returns a stack pointer of the uninitialized thread. This is when the thread is in its uninitialized state. For the client to initialize this thread, a QuickThread initialization primitive is used to initialize the stack with functions and its arguments that will be used during the execution of the thread. This initialized thread can be started by simply passing its stack pointer to a thread switching routine. This is the same way a suspended thread is restarted. The context switching works by invoking the QT switching primitive from the new thread s stack and a helper function is executed. This helper function tidies the suspension of the old thread, after which the new thread begins its execution. A detailed description of the context switching primitive is available at [35]. Examples of thread allocation and context switching routines are also provided in [35]. 2. QuickThread Client package in SystemC SystemC has two coroutine packages implemented with QuickThreads. The first is a Unix/Linux variant package and the other is a Microsoft Windows package. We limit our discussion to only the Unix/Linux variant client package. In addition, we only limit our discussion to some class definitions and some specific member functions that we believe are important for the reader to attain a basic idea of the threading coroutine package in SystemC. Figure A.1 shows a class diagram of the classes used in packaging QuickThreads in SystemC. The implementation of QuickThreads is performed in the sc cor qt and sc cor pkg qt classes. The sc cor qt class implements the data structure for the stack used in a thread. The class definition is shown in Listing A.1. The data members of this class define the stack size through m stack size, avoid pointer to the stack with m stack and the stack pointer for the thread m sp. This class only holds a pointer to the stack and does not create it. The creating object is sc cor pkg qt and hence there is a pointer of that type defined by m pkg. Class sc cor qt also inherits from an abstract class called sc cor. The only implementation Appendix A: QuickThreads in SystemC 163 sc_cor sc_cor_qt -m_stack : void* -m_sp : qt_t* -m_pkg : sc_cor_pkg_qt* -m_stack_size +stack_protect() : void +sc_cor_qt() +~sc_cor_qt() 1 -m_sp () qt_t #sc_cor() +~sc_cor() +stack_protect() : void 1 1 -m_pkg sc_cor_pkg_qt -instance_count : static int +sc_cor_pkg_qt() +~sc_cor_pkg_qt() +yield() : void +abort() : void +get_main() : sc_cor_qt sc_cor_pkg -m_simc : sc_simcontext* +sc_cor_pkg() +~sc_cor_pkg() +create() : sc_cor* +yield() : void +abort() : void +get_main() : sc_cor* +simcontext() : sc_simcontext* 1 1 -m_simc sc_simcontext () Figure A.1. Class Diagram for some of the Coroutine classes of sc cor qt are the constructor, virtual destructor and the stack protect function. The constructor simply initializes all the data members to NULL and the destructor frees up the memory if m stack is allocated. The stack protect member function however, is responsible for allocating a stack region and protecting it with appropriate privilege. The class responsible for creating the thread coroutine is sc cor pkg qt, which inherits from an abstract class sc cor pkg. The class definition of sc cor pkg qt is shown in Listing A.2. There is only one private data member in this class, which holds a static integer variable called instance count. This variable is used to ensure that there is only one instantiation of the sc cor pkg qt class further enforced by the file static variables static sc cor qt main cor and static sc cor qt* curr cor. These file static variables are instantiated in the implementation file sc cor qt.cpp. The coroutine package follows a singleton pattern [19]. The constructor of this class shown in Listing A.3 takes in a pointer to the current simulation context and sets it in the abstract class sc cor pkg and assigns the current coroutine to the address of the main cor object. No other instantiations are allowed of this class. The create(...) function takes in the stack size, a function and an argument list as mentioned earlier in our discussion of QuickThreads. In this function, the stack size is set in the sc cor qt object, the stack is allocated memory and the stack pointer is initialized along with passing of the function and arguments. At the end of the create(...) function, the thread created is returned as a pointer to sc cor object. The coroutine classes employ the use of keywords such as SCAST and RCAST. These are 164 Listing A.1. class sc cor qt 1 class sc cor qt 2 : public sc cor 4 public : 5 6 // constructor 7 sc cor qt () 8 : m stack size ( 0 ), m stack ( 0 ), m sp ( 0 ), m pkg ( 0 ) 9 {} // destructor 12 virtual sc cor qt () 1 if ( m stack!= 0 ) { delete [] (char ) m stack ; } } // switch stack protection on/ o ff 16 virtual void stack protect ( bool enable ) ; public : size t m stack size ; // stack size 21 void m stack ; // stack 22 qt t m sp ; // stack pointer sc cor pkg qt m pkg ; // the creating coroutine package private : // disabled 29 sc cor qt ( const sc cor qt& ); 30 sc cor qt& operator = ( const sc cor qt& ); 31 } ; defined in sc iostream.h as short forms for static cast and reinterpret cast, perhaps simply for easier use. The yield(...) function takes in a pointer to sc cor to indicate the next coroutine to be executed. The current coroutine to be executed is moved to a casted pointer to sc cor qt and the QuickThread primitive for blocking is called via the QT BLOCK(...) function. The arguments passed to the QT blocking primitive are the helper function, the old coroutine, and the new coroutine. The helper function saves the stack pointer onto the old thread s stack and resumes execution to the new thread using preswitch. The abort(...) member function is responsible for causing the threads to terminate (die) in a similar fashion and the get main() function returns the main coroutine for the simulation to allow continuation of the original simulation context. We do not discuss the abstract classes that are used to interface with the QT coroutine package and continue to discuss how SystemC threads make invocations to the functions described in this section. We have described some of the classes and some of the main functions of those classes that interact with the QuickThread core package. What is relevant to most SystemC users and more so to developers is how SystemC integrates these coroutine packages with their simulation environment. We describe how the Discrete-Event simulation kernel incorporates thread processes. We step through the code in giving details on how threads are instantiated (up to the coroutine client package calls) and how they are executed. Appendix A: QuickThreads in SystemC 165 Listing A.2. class sc cor pkg qt 1 class sc cor pkg qt 2 : public sc cor pkg 4 public : 5 6 // constructor 7 sc cor pkg qt ( sc simcontext simc ) ; 8 9 // destructor 10 virtual sc cor pkg qt () ; // create a new coroutine 13 virtual sc cor create ( size t stack size, sc cor fn fn, void arg ) ; // yield to the next coroutine 16 virtual void yield ( sc cor next cor ) ; // abort the current coroutine (and resume the next coroutine) 19 virtual void abort ( sc cor next cor ) ; // get the main coroutine 22 virtual sc cor get main () ; private : static int instance count ; private : // disabled 31 sc cor pkg qt () ; 32 sc cor pkg qt ( const sc cor pkg qt& ); 33 sc cor pkg qt& operator = ( const sc cor pkg qt& ); 34 } ; Listing A.3. Constructor from class sc cor pkg qt 1 sc cor pkg qt :: sc cor pkg qt ( sc simcontext simc ) 2 : sc cor pkg ( simc ) 4 if( ++ instance count == 1 ) { 5 // initialize the current coroutine 6 assert ( curr cor == 0 ); 7 curr cor = &main cor ; 8 } 9 } The initialization and execution of a thread process starts at the definition of SC THREAD(...) that is defined in sc module.h as a C macro. This macro invokes another macro called declare thread process(...) that accepts the sensitivity list and actually creates the thread process itself by calling a register thread process(...) function defined in sc simcontext class. Listing A.6 shows the constructor being called for the sc thread process class. 166 Listing A.4. create(...) member function from class sc cor pkg qt 1 sc cor 2 sc cor pkg qt :: create ( size t stack size, sc cor fn fn, void arg ) 4 sc cor qt cor = new sc cor qt ; 5 cor m pkg = this ; 6 cor m stack size = stack size ; 7 cor m stack = new char [cor m stack size ]; 8 void sto = stack align ( cor m stack, QT STKALIGN, & c o r m stack size ) ; 9 cor m sp = QT SP ( sto, cor m stack size QT STKALIGN ) ; 10 cor m sp = QT ARGS ( cor m sp, arg, cor, ( qt userf t ) fn, 11 sc cor qt wrapper ) ; 12 return cor ; 13 } Listing A.5. yield(...) member function from class sc cor pkg qt 1 void 2 sc cor pkg qt :: yield ( sc cor next cor ) 4 sc cor qt new cor = SCAST sc cor qt ( next cor ) ; 5 sc cor qt old cor = curr cor ; 6 curr cor = new cor ; 7 QT BLOCK ( s c cor qt yieldhelp, old cor, 0, new cor m sp ) ; 8 } Listing A.6. register thread process(...)
Similar documents
View more...
Related Search
We Need Your Support
Thank you for visiting our website and your interest in our free products and services. We are nonprofit website to share and download documents. To the running of this website, we need your help to support us.

Thanks to everyone for your continued support.

No, Thanks