SSP Re-hosting System: CLBM and Semantic Representations

1. SSP Re-hosting System: CLBM and Semantic Representations SSP Team Department of ECE Stevens Institute of Technology Presented by Hongbing Cheng and Jiadi Yu 09/01/2010

2. Outline • SSP Re-hosting and CLBM • Background: SSP Re-hosting for CR/SDR • Generic CLBM Rule in Signal Processing Domain • CLBM for various implementation Codes in Signal Processing Domain • Semantic Representation and Analysis • XML Representation • Tree Architecture Analysis • Tree-based Primitive Recognition

3. Part I. SSP Re-hosting and CLBM

4. Semantic Signal Processing Re-hosting for CR/SDR • Objective: • Theoretical level: Information integration and knowledge sharing in signal processing domain • Practical level: Re-hosting of radio implementations among heterogeneous platforms to facilitate the reconfiguration in CR/SDR systems • Approach: • Abstraction, Representation and Inference (ARI): Information exchange through three steps: abstraction of primitives, semantics-based representation, inference and code generation; • Cognitive linguistic behavior modeling (CLBM): Establish a semantic modeling framework for signal processing domain based on cognitive linguistics to guide the semantic ARI.

5. Semantic Signal Processing Re-hosting for CR/SDR • ARI Architecture

6. Semantic Signal Processing Re-hosting for CR/SDR Parse cognitive-linguistics-based representation and generate implementation code in the target platform Represent the implementation profile of signal processing modules/systems based on cognitive linguistics Abstract conceptual primitives (“Thing, Place, Path, Action, Cause”) from existing implementations of signal processing modules/systems in source code

7. Semantic Signal Processing Re-hosting for CR/SDR • Prototype Demo • Illustrate the workflow of the proposed ARI re-hosting • Show some use cases to validate the idea Abstraction of primitives and Representation with XML Inference and Code Generation

8. Generic CLBM Rule in Signal Processing Domain • Semantic Primitives in Cognitive linguistics • Thing: the fundamental neonatal gestalts • Place: interaction among things • Path: associate places in a sequence for a purpose • Action: Things move down paths • Cause: Thing that initiate or constraint action • CLBM: Fit the knowledge of signal processing implementation profiles into the above semantic framework

9. Generic CLBM Rule in Signal Processing Domain • Generic CLBM Rule for Signal Processing • A Signal is a “Thing” • A Signal processing system/block to be represented is a “Path” • The signal (“Thing”) moving along the signal processing system/block (“Path”) is an “Action” • Input/output ports and signal processing modules inside the “Path” is “Places”, where different signals have interactions; Attributes of a thing are also “Places”, which could be interacted with other things • A control signals that controls a signal processing flow is “Cause”

10. Generic CLBM Rule for Signal Processing Implementations Graphical Notations:

11. Generic CLBM for Signal Processing Implementations • Hierarchical and Dynamic Properties of CLBM • A “Thing” may have many “Places” to interact e.g., The power and the size of a signal are two “places” of the “thing” signal • A “Thing” could also be contained in different “places” to take different “actions” e.g., A signal could be inside a module’s input place or output place to take the action “input” or “output”

12. Generic CLBM Rule in Signal Processing Domain • Hierarchical and Dynamic Properties of CLBM • A “Path” contains multiple “Places” e.g., A transmitter could be composed of a channel coder and a modulator • A “Place” at the upper level could be a “Path” at the lower level e.g., A modulator is a ‘Place’ in a transmitter, while itself could be represented by a ‘Path’ composed of several places: LUT, Up-converter,…

13. CLBM for Implementation Codes in Signal Processing Domain • CLBM for different coding languages are required in radio re-hosting • Heterogeneous hardware or software platform • Language Elements Considered in Modeling • Syntax • Data Structure • Control Structure • Core Library

14. CLBM for Implementation Codes in Signal Processing Domain • Current work and Progress More languages More statements/syntaxes

15. CLBM for loop statements • For loop for(initiation; condition; loop control){ statement 1; statement 2; } • Initiation  place • condition  cause • statements & Loop control  path • statement  place • loop control  place

16. CLBM for loop statements • while loop

17. CLBM for “switch case” statement switch ( statement ) { case condition1 is true: statement 1; case condition2 is true: statement 2; case condition is true: statement 3; ... default: statement N; }

18. CLBM for Arrays/Vectors/Matrices • General modeling rule • An array is a “Thing” • Each element of the array is a “Place” of the “Thing” • The value of each element is the “Thing” contained in the “Place” • The size and type of the array are two “Places” of the array “Thing” This is a composited anonymous thing containing 3 element places; The first place contains 3, The second place contains 2, the third place contains 3. ‘a’ is a composited thing containing 10 element places; Its type is int. [3,2,3] int a[10]

19. CLBM in Matlab: Arrays/Vectors/Matrices • Multi-dimensional Arrays • Hierarchical property of the semantic model

20. CLBM for Arrays/Vectors/Matrices • Special definition of vectors/matrices in Matlab [1:N] ones(N,1) zeros(N,1)

21. CLBM for Arrays/Vectors/Matrices • Elements in an array • One or several elements of an array may form a new “Thing” e.g., y=a(1); a(1) is the “Thing” in the input place c(1:2)=1:2; c(1:2) is the “Thing” in the output place • The thing is got from the array’s some places, so we represent this thing by e.g. The thing is generated by getting the value of place ‘index number’ from thing ‘Array name’ a(1)

22. CLBM in C++ • Basic Features of C++ • C++ introduces object-oriented (OO) features to C. • Class: provides the abstraction and encapsulations features;  is an expanded concept of a data structure; can hold both data and functions.  • Object: Instances of class; contains member variables, constants, member functions, and overloaded operators defined by the programmer. • Our preliminary modeling work considers the basic uses of classes and objects: Definition of class and declaration of objects

23. CLBM in C++ • CLBM of class definition • Class is a composite “Thing”, which contains many “Places” to store the member variables and functions Class A { var1; var 2; … varN; func1; func2; … funcN }

24. CLBM in C++ • CLBM of object declaration • This is similar to the variable declaration • The object is a “Thing” whose type is the Class In this place, the variable a is declared, whose type is set to be A. A a;

25. CLBM in VHDL • Basic Structure of VHDL code entity NAME_OF_ENTITY is port (signal_names: modetype; signal_names: mode type; : signal_names: mode type); end [NAME_OF_ENTITY] ; VHDL Entity Interface (Entity Declaration) ports Body (Architecture) Sequential, combinational processes architecture architecture_name of NAME_OF_ENTITY is -- Declarations -- components declarations -- signal declarations -- constant declarations -- function declarations -- procedure declarations -- type declarations begin -- Statements end architecture_name; subprogram

26. CLBM in VHDL • General CL modeling rules VHDL Entity Interface (Entity Declaration) ports Body (Architecture) Sequential, combinational processes subprogram

27. CLBM in VHDL • Challenges • Unique structure • Need to abstract input and output places from the entity and other places in the path from the architecture • May have multiple architectures for one entity • Special data types: • std_logic, std_logic_vector • bit, bit_vector • Many unique keywords • Sequential programs and parallel programs

28. CLBM in VHDL • Example: Adder -- VHDL code for 3-bit adder ------------------------------------- entity ADDER is port(A: in std_logic_vector(1 downto 0); B: in std_logic_vector(1 downto 0); carry: out std_logic; sum: out std_logic_vector(1 downto 0) ); end ADDER; architecture behv of ADDER is signal result: std_logic_vector(2 downto 0); begin -- the 3rd bit should be carry result <= ('0'&A)+('0'&B); sum <= result(1 downto 0); carry <= result(2); end behv; size of A type of A

29. Part II. Semantic Representation and Analysis

30. Semantic Representation based on CLBM • XML is proposed as the carrier of cognitive linguistics to represent signal processing implementations. • XML is designed to describe and carry data to exchange information between incompatible systems. Converting the data to XML can greatly reduce this complexity and create data that can be read by many different types of applications. • The proposed XML representation is able to express knowledge of the signal processing implementation based on CLBM.

31. XML representation framework for SSP

32. XML representation for SSP control structures

33. Generic CLBM for Signal Processing Implementations • Hierarchical and Dynamic Properties of CLBM • A “Path” contains multiple “Places” e.g., A transmitter could be composed of a channel coder and a modulator • A “Place” at the upper level could be a “Path” at the lower level e.g., A modulator is a ‘Place’ in a transmitter, while itself could be represented by a ‘Path’ composed of several places: LUT, Up-converter,…

34. An Adaptive Modulator Example

35. Architecture Analysis • The representation architecture based on cognitive linguistics of the signal processing implementation is a tree structure.

36. Architecture Analysis • XML documents are a tree structure that starts at “the root” and branches to “the leaves”. Therefore, XML is able to represent correctly the architecture of the signal processing implementation. • In the Semantic Signal Processing architecture, producing a XML document is a process to build a tree, and parsing a XML document is a process to query a tree. XML is able to represent correctly tree structure. Therefore, XML representation can guarantee a correct output order. • The complexity for producing a XML document is O(n), and the complexity for parsing a XML document is O(n).

37. Tree Architecture Representation Based on CLBM • Behavior Pattern of CLBM • Tree representation of behavior patterns

38. Tree representation for SSP control structures

39. An Adaptive Modulator Example D0={PathAdaptiveModulator, D1, D2, D3, D4}

40. A Simple Filter Example http://sites.google.com/site/stevensxingzhong/home/clmb void main(){ int i; int N; int k; int temp; int sum; sum = 0; for(i = 0; i < N ; i = i + 1){ k = N - i; temp = tap[i] * input[k]; sum = sum + temp; } }

41. SP/Radio Primitive Recognition based on Tree • Objective • Automated recognition of functionality of a SP/Radio primitive • Automated recognition of functions from knowledge library to perform desired action • Recognize the equivalence of two different implementations

42. Radio-Level Abstraction • Abstract primitives at Radio-level • Analyze the Code-level primitives to recognize Radio-level primitives Primitives of Semantic Radio Code level Radio level Algebraic calculation: +, -, *, / Logic calculation: xor, nor, and Type conversions Relational Operator： ==，！= Conditional control: if… else…, while : Signal Sources Signal Sinks Filters Signal Modulation Signal Demodulation Source coding Synchronization Equalization AGC OFDM locks :

43. Radio-Level Abstraction (cont’) Radio Level Abstraction Inference Engine Radio Primitives Radio level XML Presentation Knowledge Base Target Code Code level XML Presentation Code level Abstraction Sources Code SP module recognition

44. Tree-based Pattern Recognition • Each signal processing module can be represented as a behavior pattern using lower-level primitives • Tree representation of behavior patterns. Each signal processing module can be represented as a tree architecture. • Pattern recognition: compare the tree representation of a primitive with the tree representation of each module in the knowledge base to identify the functionality of the primitive by analyzing the tree architecture of radio modules.

45. Tree-based Pattern Recognition Primitive Recognition Source Tree representation Tree architecture analyze Target Knowledge base

46. A Simple Filter Example- based on features void main(){ for(i = 0; i < N ; i = i + 1){ k = N - i; temp = tap[i] * input[k]; sum = sum + temp; } } The basic element for the simple filter include: • LOOP • ACCUMLATION • MULTIPLY • ARRAY

47. An Example of QPSK- based on architecture • two QPSK implementations Binary Tree representation Tree representation

48. Thank You!Question and Comments?