1 / 31

Applications

Applications. t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/. VHDL-Parser Pretty-Printer System. t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/. URLs. Online Parser Documentation http://www.cs.wright.edu/~tkprasad/VHDL/VHDL-AMS/START.html Public Distribution

taini
Télécharger la présentation

Applications

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Applications t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/ L13Applications

  2. VHDL-Parser Pretty-Printer System t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/ L13Applications

  3. URLs • Online Parser Documentation • http://www.cs.wright.edu/~tkprasad/VHDL/VHDL-AMS/START.html • Public Distribution • http://www.cs.wright.edu/~tkprasad/VHDL/VHDL-AMS.zip L13Applications

  4. A Meta-Interpreter for circuit Extraction t.k.prasad@wright.edu http://www.knoesis.org/tkprasad/ L13Applications

  5. Outline • Formal Description of Digital Circuits • Design Verification • Motivation for Applying Meta-programming Techniques • Implementation and Correctness Considerations • Conclusions L13Applications

  6. Hierarchical Description of Circuit Design Full-Adder Half-Adder Sub-Components Abstraction AND-OR-NAND Gates Gate-level Description CMOS Transistors Transistor Netlist Component L13Applications

  7. Declarative Specification of the Structure: Inverter and Netlist Single Inverter: inv(In,Out,X,Y) :- pt(In,vdd,Out,X,Y), nt(In,gnd,Out,_,_). Netlist: pt(in1,vdd,out1,50,50). nt(in1,gnd,out1,50,40). pt(out1,vdd,out2,100,50). nt(out1,gnd,out2,100,40). GND L13Applications

  8. Problem and Solution Strategy • Verify structural correctness of a component layout by reverse engineering the top-level design. • Use automatically generated Prolog extraction rules • Prolog specifications are executable and can be used to simulate the circuit or check for faults by designing suitable queries L13Applications

  9. Circuit Extraction MAGIC (CAD Tool) Layout TRANSLATE Netlist : Prolog Facts EXTRACT Higher-level Components L13Applications

  10. Extraction Rules in Prolog extract_inverter :- pt(In,vdd,Out,X,Y), nt(In,gnd,Out,_,_), remove_pt(In,vdd,Out), remove_nt(In,gnd,Out), asserta(inverter(In,Out,X,Y)). L13Applications

  11. Finer Points • Retracts not undone on backtracking => Identify complete component before retracting • Retract all occurrences of a component => Use “fail” appropriately. L13Applications

  12. Spec vs Extraction Template component :- subcomponent_1 subcomponent_2. extract_component :- subcomponent_1 subcomponent_2, retract(subcomponent_1), retract(subcomponent_2), assert(component), fail. L13Applications

  13. Problem and Our Solution • Requires generation of customized extraction rules (for each component) explicitly (which causes duplication of information). • Use meta-programming techniques to perform extraction “on-the-fly” using declarative specification of the structure of the component. L13Applications

  14. Advantage: Avoids explicit creation and storing of extraction rules • Disadvantage: Meta-interpretation is slower than using customized extraction rules • Pragmatically: Explicit rules are good for extracting low-level components, while meta-interpreter is good for extracting high-level component extraction L13Applications

  15. Meta-Rule extract(Comp) :- clause(Comp, Sub_Comps), Sub_Comps \== true, call(Sub_Comps), remove_primitive(Sub_Comps), asserta(Comp), fail. extract(_). L13Applications

  16. remove_primitive((C1,C2)) :- !, remove_primitive(C1), remove_primitive(C2). remove_primitive(C) :- clause(C,true), !, retract(C). remove_primitive(C) :- clause(Comp,Sub_Comps), remove_primitive(Sub_Comps). L13Applications

  17. (cont’d) • The interpreter does not work properly if the definition also contains ordinary predicates, written to capture connectivity constraints, position calculations, etc. • Introduce special meta-predicate constraint as follows: constraint(Test) : - call(Test). remove_primitive(constraint(_)):-!. L13Applications

  18. Example invZ(P,N,I,O,X,Y) :- pt(I,vdd,Q,X1,Y1), pt(P,Q,O,X2,Y2), nt(N,O,R,X3,Y3), nt(I,R,gnd,X4,Y4), constraint( \+ connected([Q,R,vdd,gnd]) ), constraint( X is (X1+X2+X3+X4)/4, Y is (Y1+Y2+Y3+Y4)/4 ). L13Applications

  19. Correctness Issue • Facts and rule-heads are disjoint. The lowest-level is represented as facts. Retraction of facts is sufficient. • Each fact contributes to just one rule. Subcomponents are not shared. Retraction of a fact does not interfere with the extraction of other components. (Stratification of sorts) L13Applications

  20. Conclusion • Meta-interpreter approach uses the declarative specification of a design directly, to perform extraction. • This approach is flexible, for higher-level components. The trade-off is that it is inefficient for lower-level components. L13Applications

  21. Meta-Interpreters Ref: Yoav Shoham’s AI Techniques in Prolog L13Applications

  22. Types Extensions Expert systems Mycin Abductive Reasoning Diagnosis Annotated Logic Programming • Backward Chaining (Top-down) • Depth-first • Prolog • Breadth-first • Forward Chaining (Bottom-up) • Production Systems L13Applications

  23. Representing forward chaining rules op(1000, xfy, ‘,’). op(1150, xfx, ‘-:’). p -: q. r,s -: p. q -: t. • Forward chaining adds new conclusions using rules in response to facts of the database and the newly asserted conclusions. L13Applications

  24. Membership in and-list amember(X, (A,B)) :- !, ( X = A; amember(X,B)). amember(A,A). • Recall op(_, xfy, ‘,’). L13Applications

  25. Propagating the effect of facts • Forward chaining interpreter recursively determines the conclusions forced by the facts and the rules, and asserts them explicitly. • Given the set of rules, each fact is asserted one by one (using the code shown on the next slide) and the conclusions implied by them are determined. • Specifically, the head of a rule is asserted after all the literals in the body of the rule have been asserted. L13Applications

  26. Propagating the effects of facts update(X) :- clause(X, true),!. update(X) :- assert(X), ( If -: Then ), amember(X, If), \+((amember(Y, If), \+(clause(Y, true)))), update(Then), fail. L13Applications

  27. Propagating the effect of facts • Complexity of update() • O( number of rules * number of body literals) • Can be optimized and extended to include negative literals, deletion, and maintaining justifications. • Reference: Chapter 4 of YoavShoham’s AI Techniques in Prolog L13Applications

  28. Pooling of Evidence : The Mycin approach Ref: Yoav Shoham’s AI Techniques in Prolog L13Applications

  29. Introducing Certainty Factor • Facts => CF = 1 • Rules => CF in [0,1] high_fever. (1) malaria :- high_fever, recently_in_jungle. (0.8) malaria :- … L13Applications

  30. Mycin Interpreter cert(true, 1). cert( (A,B), C) :- !, cert(A , C1), cert(B, C2), comb_fn_serial(C1, C2, C). cert( A, C) :- !, findall(CC, (clause(A,B,CF), cert(B , CC)), CLst), comb_fn_parallel(CLst, C). L13Applications

  31. Other Static Analysis Tools • Type Checking/Inference append(list(X), list(X), list(X)). fact(int, int). • Mode Inference append(+,+,_) L13Applications

More Related