ECE 449 OOP and Computer Simulation Lecture 07 Class Design for Circuit Netlist

Transcription

1 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 1/64 ECE 449 OOP and Computer Simulation Lecture 07 Class Design for Circuit Netlist Professor Jia Wang Department of Electrical and Computer Engineering Illinois Institute of Technology October 6, 2017

2 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 2/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

3 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 3/64 Reading Assignment This lecture: Project 3 Specification Next lecture: 4.1, 11

4 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 4/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

5 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 5/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

6 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 6/64 Building Building: create an executable from a set of source files What is the building process for C++ programs? Why is it designed that way? How should we leverage it to improve productivity? Reuse existing codes/libraries save coding time! Catch typos and mistakes save debugging time!

7 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 7/64 Compiler and Compiling Compiling is the process to turn source codes into binary forms. Many typos and mistakes can be identified by compiler during compiling. The compiler will refuse to generate binary codes until you correct all compiling errors. Example 1: undeclared names Is there a typo in your variable or function name? Are you trying to access a variable or function out of its scope? Example 2: unmatched types Are you assigning a wrong value to a variable? Are the arguments to a function passed in wrong order?

8 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 8/64 Correcting Compiling Errors Don t get frustrated if your code won t compile successfully. Always start with the first error message the remaining ones may simply go away if the first one is corrected. Repeat when necessary until all errors are corrected Read the error message carefully to determine what s wrong. An error message usually starts with the file name and line # that you can locate the line causing the error IDEs may even bring you to the line directly if you double click the error message. Try to follow the description of the error thereafter Only a few types of error messages appear frequently and you will quickly get familiar with them as you code your projects.

9 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 9/64 Separate Compilation So far we have a single C++ file which will be compiled into an executable using the compiler. Even with functions and data types, issues arise when the program becomes more complicated. There are still chances some code is changed accidentally. It takes longer to compile a larger file. Separate compilation: use multiple files for a program Reduce complexity by separating interfaces and implementations Reduce build time by compiling modified files only Reduce chances of accidental changes by copying files instead of code snippets

10 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 10/64 Building, Compiling, and Linking Separate compilation consists of two stages. Usually the whole process is known as building. Stage 1: compiling (by compilers) Convert each source file into an object file (the word object here has nothing to do with OOP) Source files may be written in different programming languages as long as the interfaces are compatible. Stage 2: linking (by a linker) Combine object files into one executable Pre-compiled object files can be provided by a third-party who otherwise won t provide source files. Pre-compiled object files are usually organized into library files.

11 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 11/64 Build Management Compiling For each source file, determine the compiler to compile it To save compiling time, only modified source files should be compiled for each successive build. Determine compiling options Linking Locate the necessary library files Determine the linking options At different stages in software development, the executable may need to be built in different ways. For debugging: comprehensive diagnosis information For final product release: optimize for performance IDEs usually provide automatic build management. Otherwise, a build management tool, e.g. GNU Make, is required. For simplicity, on our CI system, we build with a single command for final product release.

12 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 12/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

13 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 13/64 Function Interface and Implementation bool extract_tokens_from_file(std::string file_name, evl_tokens &tokens) {... // implementation omitted Interface: inputs and outputs of the function, i.e. parameter and return types Implementation: the method to generate outputs from given inputs, i.e. function body Separate compilation for C++ The compiler only need to know the interfaces The linker will locate the implementations

14 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 14/64 Function Declaration // main.cpp bool extract_tokens_from_file(std::string file_name, evl_tokens &tokens); int main(int argc, char *argv[]) {... // verify that argv[1] exists evl_tokens tokens; if (!extract_tokens_from_file(argv[1], tokens)) { return -1;... // display tokens and store them to file Function declaration Define the interface to the function for the compiler Function header followed by ;

15 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 15/64 Function Definition // tokens.cpp bool extract_tokens_from_file(std::string file_name, evl_tokens &tokens) { std::ifstream input_file(file_name.c_str());... std::string line; for (int line_no = 1; std::getline(input_file, line); ++line_no) {... return true; Function definition Function header + function body Define the implementation of the function There should be exactly one definition for each function among all the source files.

16 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 16/64 Issues with Separate Compilation Each source file should contain the declarations for the functions it intends to use. Plus user-defined data types used in those declarations It is tedious to maintain their consistency among multiple source files. Any mismatch in function declaration and function definition will result in linking errors. The linker won t find the desired implementation. Any mismatch of a user-defined data type in multiple source files will result in undefined behavior.

17 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 17/64 Header Files // tokens.h struct evl_token {... ; // struct evl_token typedef std::list<evl_token> evl_tokens; bool extract_tokens_from_file(std::string file_name, evl_tokens &tokens); The most straightforward way to save typing and to maintain consistency is to organize interfaces into header files and to allow source files to access them. Then you will never have mismatched data types. Mismatched function declaration and definition will be caught by linker and is not a concern.

18 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 18/64 Translation Unit // main.cpp #include <vector> #include <iostream> #include <fstream> #include "tokens.h" int main(int argc, char *argv[]) {... // verify that argv[1] exists evl_tokens tokens; if (!extract_tokens_from_file(argv[1], tokens)) { return -1;... // display tokens and store them to file Use #include with "" to include your header files You can include header files from other header files. The source file, together with all the header files it includes directly or indirectly (through other header files), is called a translation unit.

19 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 19/64 #include Guard #ifndef GUARD_TOKENS_H #define GUARD_TOKENS_H struct evl_token {... ; // struct evl_token typedef std::list<evl_token> evl_tokens; bool extract_tokens_from_file(std::string file_name, evl_tokens &tokens); #endif A header file may appear more than once in a translation unit, resulting in compiling errors, e.g., A data type from the header file is defined more than once. There may exist cyclic dependences among header files. Use a #include guard to prevent a header to appear more than once in a translation unit. The header is still included multiple times, though it is only seen by the compiler for the first time.

20 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 20/64 Working with Classes date.h // date.h #ifndef GUARD_DATE_H #define GUARD_DATE_H class date { int year, month, day; public: date(int y, int m, int d); void display(std::ostream &out) const; bool set(int y, int m, int d); ; // class date #endif Don t forget the ; at the end of the class definition. If you see strange compiling error messages, double check all your class definitions for the ;.

21 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 21/64 Working with Classes date.cpp // date.cpp #include <iostream> #include "date.h" date::date(int y, int m, int d) : year(y), month(m), day(d) { void date::display(std::ostream &out) const { out << year << "/" << month << "/" << day << std::endl; bool date::set(int y, int m, int d) {...

22 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 22/64 Working with Classes other.cpp // other.cpp - any other cpp file #include <iostream> #include "date.h" void some_function() { date someday(2017, 10, 8);...

23 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 23/64 Managing Your C++ Files All your source files (.cpp) and header files (.h) should be stored in src. Otherwise, the compiler may fail to find some of your files when building your project. Unused.cpp and.h files should be removed. Don t forget to add all your source files and header files to your repository. Otherwise, the linker may fail to locate some of your function/class implementations. While you won t need separate compilation for Project 2, we believe you need it to manage the complexity of the projects thereafter.

24 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 24/64 Resolving Common Linking Errors Multiple definitions of a function, e.g. main. There should be exactly one definition for each function among all the source files. Did you put a function definition instead of its declaration into a header file? Missing definition of a function. Make sure the parameters of the function declaration matches its definition. Make sure you have git add the.cpp file containing the function definition. Multiple definitions of a class/struct. Don t put a class/struct definition into a.cpp file. Did you use #include guard for all your header files? If you still have troubles, talk to us immediately. Don t waste you time it may take you days to figure out some trivial mistakes when setting up separate compilation.

25 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 25/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

26 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 26/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

27 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 27/64 A 4-Bit Counter module counter4; wire s0, s1, s2, s3, n0, n1, n2, n3, c0, c1, c2, c3; // input/output evl_one(c0); evl_output O(s3, s2, s1, s0); // states wire clk; evl_clock(clk); evl_dff F0(s0, n0, clk); evl_dff F1(s1, n1, clk); evl_dff F2(s2, n2, clk); evl_dff F3(s3, n3, clk); // compute n=s+1 xor X0(n0, s0, c0); xor X1(n1, s1, c1); xor X2(n2, s2, c2); xor X3(n3, s3, c3); and A0(c1, s0, c0); and A1(c2, s1, c1); and A2(c3, s2, c2); endmodule // counter4

28 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 28/64 The Schematic 13 wires, 14 components (clk/evl_clock are not shown) From Project 1 and 2, we know how to obtain them individually in our program. Need to be organized in our C++ program. For simulation, etc.

29 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 29/64 Logic Simulation and Circuit Netlist Programs=Data Structures+Algorithms They are the major contributors to the performance. How to organize them, on the other hand, affects everything else. Logic simulation basics A gate computes output logic signal(s) based on input logic signals according to its pre-defined functionality. A net passes a bit of logic signal from the output of a gate to inputs of other gates. The logic simulation algorithm coordinates computations by gates and communications by nets. Netlist: a data structure to represent circuits in programs Constructed from components and wires in the EasyVL file Provide necessary information to the logic simulation algorithm

30 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 30/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

31 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 31/64 Class Design for Complex Systems So far we have some experiences in designing a single class. For a complex system, the unit of design is a collection of classes, rather than an individual class. A complex system usually involves many different objects interacting with each other, requiring to compose classes/objects for ownership and beyond. Such a collection is often called a library or a framework, and is also the unit of reuse and maintenance. Though class design depends on the system itself, we can follow object-oriented design (OOD) practices. An effective method in the very beginning of OOD. Describe the system in natural language Nouns are candidates of classes. Verbs give hints to class responsibilities and members. Further improvements can be made based on class invariants and invariants between classes.

32 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 32/64 What is a Netlist? Gates and nets Gates are constructed from components, e.g. xor Nets are constructed from wires we use the word net here since in EasyVL a wire can pass multiple bits of signals. Gate contains pins Nets connect to a gate through its pins. Different pins have different functionality according to their order in the gate. A net connects to multiple gates through multiple pins. We identify the gate driving the net and the gates driven by the net by deciding the direction of the pin, i.e. output and input. The netlist is the collection of the gates/nets/pins. This is usually known as structural representation of a circuit.

33 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 33/64 Entity-Relationship (ER) Diagram We use ER diagram to visualize the structural representation. ER diagrams are widely used for database designs otherwise. Entities (box), relationships (diamond), attributes (oval).

34 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 34/64 Class Design Ideas Each entity corresponds to a class type. Use data members to store attributes. Use additional data members to store directly associated relationships and their attributes. Use getters/setters to access attributes and relationships.

35 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 35/64 Possible Class Design (with Some Issues) Name every pin objects. For relationship gate contains pins, Store in each gate object a vector of the names of the pin objects. Store in each pin object the name of the gate it belongs to and an index of the relationship. For relationship net connects pins, Store in each net object a vector/list of the names of the pin objects. Store in each pin object the name of the net it connects to. The netlist class holds three containers to store the gate/net/pin objects. To access a specific gate/net/pin object, simply search through the containers to find it by name. Any problem?

36 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 36/64 Improvements Search by name is too slow, even if you use std::maps in netlist to hold gate/net/pin objects. Need O(log n) time to access each related object. To avoid repeated search, we use pointers to refer to objects instead of using their names. Search once when creating the object and store the results as pointers. Allow to access a related object in O(1) time.

37 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 37/64 Class Design class net { std::string name_; // e.g. "a", "s[0]" char signal_; // e.g. 0 or 1 std::list<pin *> connections_; // relationship "connect" ; // class net class pin { char dir_; // e.g. I or O gate *gate_; // relationship "contain" size_t index_; // attribute of "contain" net *net_; // relationship "connect" ; // class pin class gate { std::string name_; std::string type_; // e.g. "and", "or" std::vector<pin *> pins_; // relationship "contain" ; // class gate class netlist { std::list<gate *> gates_; std::list<net *> nets_; ; // class netlist

38 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 38/64 What the netlist looks like for this circuit? // a comment module top; wire s0, s1, clk; evl_clock(clk); evl_dff(s0, s1, clk); not(s1, s0); endmodule

39 The Netlist ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 39/64

40 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 40/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

41 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 41/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

42 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 42/64 Cyclic Dependencies among Types class A { B *b_; ; // class A class B { A *a_; ; // class B C++ requires a type to be defined before being used. The above code won t compile since B is not defined when we define A. It won t help if we define B first, since then A is not defined yet when we define B. However, defining A and B in such a way does make sense. Especially when there are many objects interacting with each other.

43 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 43/64 Forward Declarations class B; // forward declaration class A { B *b_; ; // class A class B { A *a_; ; // class B Since A only holds a pointer to B, the compiler doesn t need to know the detailed implementations of B when defining A. In such case, the compiler only need to know that B is a class. Through a forward declaration of B.

44 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 43/64 Forward Declarations class B; // forward declaration class A { B *b_; ; // class A class B { A *a_; ; // class B Since A only holds a pointer to B, the compiler doesn t need to know the detailed implementations of B when defining A. In such case, the compiler only need to know that B is a class. Through a forward declaration of B.

45 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 44/64 Some Cases Cannot Be Resolved by Forward Declarations class B; class A { B b_; ; // class A class B { A a_; ; // class B It doesn t make sense for A to have a member of type B and for B to have a member of type A at the same time.

46 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 45/64 Updated Class Design with Forward Declarations // netlist.h #ifndef GUARD_NETLIST_H #define GUARD_NETLIST_H class netlist; class gate; class net; class pin; class net {... ; // class net class pin {... ; // class pin class gate {... ; // class gate class netlist {... ; // class netlist #endif

47 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 46/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

48 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 47/64 Creating Netlist How to create a netlist depends on the information that is readily available. I.e. the objects we created in Project 1 and 2. A netlist object can be created as follows Create net objects from wires Create gate objects from components Create pin objects within each gate Make connections between pins and nets Validate semantics as necessary.

49 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 48/64 A Possible Interface to Project 1 and 2 struct evl_wire { std::string name; int width; ; // struct evl_wire typedef std::list<evl_wire> evl_wires; struct evl_pin { std::string name; int bus_msb, bus_lsb; ; // struct evl_pin typedef std::list<evl_pin> evl_pins; struct evl_component { std::string type, name; evl_pins pins; ; // evl_component typedef std::list<evl_component> evl_components; bool parse_evl_file(std::string evl_file, std::string &module_name, evl_wires &wires, evl_components &comps); Assume everything we completed in Project 1 and 2 is hidden inside the function parse_evl_file.

50 steps to create the netlist. ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 49/64 Interface Design for netlist int main(int argc, char *argv[]) {... // validate arguments std::string module_name; evl_wires wires; evl_components comps; if (!parse_evl_file(argv[1], module_name, wires, comps)) return -1; evl_wires_table wires_table; if (!make_wires_table(wires, wires_table)) return -1; netlist nl; if (!nl.create(wires, comps, wires_table)) return -1; std::string nl_file = std::string(argv[1])+".netlist"; nl.save(nl_file, module_name); // save the netlist for Project 3 nl.simulate(1000); // simulate 1000 cycles for Project 4 return 0; Let s assume the member function create will take care of all

51 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 50/64 Implement netlist::create bool netlist::create(const evl_wires &wires, const evl_components &comps, const evl_wires_table &wires_table) { return create_nets(wires) && create_gates(comps, wires_table); Let s take a top-down approach. Divide responsibilities into smaller pieces until you know how to implement them. Hand over the creation to the other two member functions. They should be private as they are not supposed to be used outside the class. It makes sense to create nets first since they are needed when connecting pins to nets. Note that short-circuit evaluation ensures if create_nets fails, then create_gates would NOT be called.

52 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 51/64 Implement netlist::create nets bool netlist::create_nets(const evl_wires &wires) { for each wire w in wires { if (width of w == 1) { create_net(w); else { for (int i = 0; i < width of w; ++i) { create_net(w[i]); Let s simplify our slides by using pseudo code. We further delegate the creation of a net object to another member function create_net. When connecting pins to nets, we need to find nets by their names. How to generate the name w[i] of each net as a string? How to search efficiently?

53 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 52/64 Generate Net Names std::string make_net_name(std::string wire_name, int i) { assert(i >= 0); std::ostringstream oss; oss << wire_name << "[" << i << "]"; return oss.str(); We can use std::ostringstream, which allows to save the stream output to a string. From the standard header sstream

54 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 53/64 Implement netlist::create net class netlist {... std::map<std::string, net *> nets_table_;... ; // class netlist void netlist::create_net(std::string net_name) { assert(nets_table_.find(net_name) == nets_table_.end()); net *n = new net(net_name); nets_table_[net_name] = n; nets_.push_back(n); net objects are created on the heap. Use an associative container to facilitate search. You would need to implement ctor of the net class by yourself.

55 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 54/64 Implement netlist::create gates and netlist::create gate bool netlist::create_gates(const evl_components &comps, const evl_wires_table &wires_table) { for each component c in comps { create_gate(c, wires_table); bool netlist::create_gate(const evl_component &c, const evl_wires_table &wires_table) { gate *g = new gate; gates_.push_back(g); return g->create(c, nets_table_, wires_table); Similar to netlist, we choose to create a gate (create pins and make connections) using its member function create instead of using a ctor. It is necessary to provide wires_table for semantics of pins and nets_table_ for making connections between pins and nets.

56 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 55/64 Implement gate::create and gate::create pin bool gate::create(const evl_component &c, const std::map<std::string, net *> &nets_table, const evl_wires_table &wires_table) { set gate type and name; size_t index = 0; for each evl_pin ep in c { create_pin(ep, index, nets_table, wires_table); ++index; return validate_structural_semantics(); bool gate::create_pin(const evl_pin &ep, size_t index, const std::map<std::string, net *> &nets_table, const evl_wires_table &wires_table) { resolve semantics of ep using wires_table pin *p = new pin; pins_.push_back(p); return p->create(this, index, ep, nets_table); Similar to gate, we create a pin (make connections to nets) using its member function create.

57 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 56/64 Implement pin::create and net::append pin bool pin::create(gate *g, size_t index, const evl_pin &p, const std::map<std::string, net *> &nets_table) { store g and index; if (p.msb == -1) { // a 1-bit wire net_name = p.name; net_ = find net_name in nets_table net_->append_pin(pin); else { // a bus... void net::append_pin(pin *p) { connections_.push_back(p); What if the pin connects to a bus? Don t worry about this until you have passed many golden tests. You will need to modify the ER diagram and then the class design to accommodate this feature.

58 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 56/64 Implement pin::create and net::append pin bool pin::create(gate *g, size_t index, const evl_pin &p, const std::map<std::string, net *> &nets_table) { store g and index; if (p.msb == -1) { // a 1-bit wire net_name = p.name; net_ = find net_name in nets_table net_->append_pin(pin); else { // a bus... void net::append_pin(pin *p) { connections_.push_back(p); What if the pin connects to a bus? Don t worry about this until you have passed many golden tests. You will need to modify the ER diagram and then the class design to accommodate this feature.

59 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 57/64 Outline Understand Building The Building Process Header Files and Translation Units Netlist Logic Simulation and Circuit Netlist Object-Oriented Design Netlist Construction Forward Declaration Creating Netlist Destructor and Copy Control

60 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 58/64 No delete? There is nowhere in our code that deletes the nets/gates/pins we created on the heap. Recall it s the responsibility of C++ programmers to destroy the objects on the heap (and return the memory to the heap). When should objects on heap be deleted? It s hard to answer in general and depends on your design. We can always delegate the responsibility to a class. In our design, since the objects are used by many classes, we can assign the responsibility to delete an object to the class that created it. Ownership: netlist owns gates and nets, gate owns pins. This is also the common and recommended practice for C++.

61 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 59/64 Destructors // netlist.cpp gate::~gate() { for (size_t i = 0; i < pins_.size(); ++i) delete pins_[i]; netlist::~netlist() {... // delete pointers stored in gates_ and nets_ The destructor (dtor) is a special member function. Has the name of ~ plus the class name Won t return a result and takes no argument Will be called automatically when the object is destroyed. Unlike ctors, a class has exactly one dtor. Where are the dtors for other classes?

62 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 60/64 Member Destruction and Implicitly-Declared Destructor You don t need to destroy the members explicitly in the dtor. The members are destroyed after the body of the dtor. The compiler will generate code for that purpose the containers in gate and netlist will be destroyed correctly. So you can still use the members in the dtor. Moreover, the compiler will generate an empty public dtor for any non-reference type if the type has no user-defined dtor. For built-in types, it will do nothing. For class types, it will destroy their members the containers in net and pin will be destroyed correctly.

63 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 61/64 Understanding Destruction for Containers What gets destroyed when a container is destroyed? The container and all its elements are destroyed. What if the elements are pointers? The pointers, as objects themselves, are destroyed. The objects pointed by the pointers are not destroyed. Whether those pointers need to be deleted depends on the ownership. So we delete the points from gates_ and nets_ in netlist, and from pins_ in gate, while we don t do anything for those from connections_ in net, and from nets_table_ in netlist.

64 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 62/64 Automatic Object Destruction int main(int argc, char *argv[]) {... netlist nl; if (!nl.create(wires, comps, wires_table)) return -1;... return 0; nl is a local variable and will be destroyed automatically when the function main returns. The dtor of nl is guaranteed to be called automatically at every exit of the function. So all gates and nets will be destroyed. When gates are destroyed, pins will also be destroyed.

65 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 63/64 Copy and Assignment The C++ compiler will implement copy and assignment of objects automatically as we will learn later. However, our current class design does not work well with such automatic implementations. Conceptually, it is a bad idea to make copies of gate, pin, net objects since we have to maintain invariants among them. We will simply disable such implementations like follows. class net { net(const net &) = delete; net &operator=(const net &) = delete;... ; // class net Details will be explained in later lectures.

66 ECE 449 Object-Oriented Programming and Computer Simulation, Fall 2017, Dept. of ECE, IIT 64/64 Summary and Advice Separate compilation supports the separation of interfaces and implementations. In a translation unit, functions should be declared and types should be defined before being used. Use header files to manage function declarations and type definitions Use #include guard in every header file Assign responsibility to each class. Let each class does its own job avoid to expose private data members as much as you can. Plan ahead for allocating objects from heap. Prefer to manage the lifetime of an object on the heap by constructing and destroying it in the same class using ctor/dtor, plus copy control (will be introduced later). Otherwise, use GC (will be introduced later).