《软件体系结构过程调用体系结构CallReturnSystems.ppt》由会员分享，可在线阅读，更多相关《软件体系结构过程调用体系结构CallReturnSystems.ppt（71页珍藏版）》请在三一文库上搜索。
1、软件体系结构 过程调用体系结构 Call/Return Systems,孙志岗 , ,2,2019/8/9,History,Main program and subroutines Decomposition into processing steps with single-threaded control 单线程控制，划分为若干处理步骤 Functional modules Aggregation of processing steps into modules 把处理步骤集成到模块内 Abstract Data Types Bundle operations and data, hide
2、 representations and other secrets 操作和数据捆绑在一起，隐藏实现和其他秘密, ,3,2019/8/9,History,Objects Methods (bound dynamically), polymorphism (subtypes), reuse (through inheritance) 方法（动态绑定），多态（子类），重用（继承） OO Architectures Objects as separate processes/threads 对象活动与不同的进程/线程 Client-server, tiered styles Components M
3、ultiple interfaces, binary compatibility, advanced middleware （多个接口，二进制兼容，高级中间件）, ,4,2019/8/9,Main Program and Subroutine, ,5,2019/8/9,Main Program and Subroutine,Hierarchical decomposition: 逐步分解 Based on definition-use relationship 基于定义使用关系 Uses procedure call as interaction mechanism 用过程调用作为交互机制 S
4、ingle thread of control: 单线程控制 Supported directly by programming languages 程序设计语言直接支持, ,6,2019/8/9,Main Program and Subroutine,Hierarchical reasoning: 推论 Correctness of a subroutine depends on the correctness of the subroutines it calls 子程序的正确性取决于它调用的子程序的正确性 Subsystem structure implicit: 子系统的结构不清晰 S
5、ubroutines typically aggregated into modules 子程序通常合成为模块, ,7,2019/8/9,Main Program and Subroutine, ,8,2019/8/9,Criteria for Modularization,What is a module? Common view: a piece of code. Too limited. Compilation unit, including related declarations and interface （编译单元，包含相关的声明和接口） Parnas: a unit of wo
6、rk. Why modularize a system, anyway? Management: Partition the overall development effort divide and conquer (分而治之) Evolution: Decouple parts of a system so that changes to one part are isolated from changes to other parts 进化：降低模块间的耦合度，使改变一个模块不会影响其他 Understanding: Permit system to be understood as c
7、omposition of mind-sized chunks 理解：系统可以被理解成若干个易于理解的模块的组合 Key issue: what criteria to use for modularization, ,9,2019/8/9,Modularization Problems,Access to internal representation: Vulnerability: Visible representations can be manipulated in unexpected, undesired, and dangerous ways Nonlocality: If t
8、he way something is used depends on its implementation, you must find all uses to change it (e.g. Y2K) Forced distribution of knowledge: Non-uniform referents: Syntax may reveal structure (If you export a data structure, how does its user iterate through it?), ,10,2019/8/9,Modularization Problems,Co
9、upling: Instance dependence: When multiple instances of a given structure are active, they must remain independent Families of definitions: (众说纷纭) Dynamic binding: If shared definitions involve type variants, function variants must be chosen at run-time, ,11,2019/8/9,Module Decomposition,Parnas Hide
10、 secrets. OK, whats a “secret”? Representation of data Properties of a device, other than required properties Mechanisms that support policies Try to localize future change Hide system details likely to change independently 把可能改变的系统细节分别隐藏 Expose in interfaces assumptions unlikely to change 把改变的可能不大的
11、放到接口当中 Use functions to allow for change Theyre easier to change than visible representation, ,12,2019/8/9,Key Word In Context (KWIC),Problem Description: “The KWIC index system accepts an ordered set of lines, each line is an ordered set of words, and each word is an ordered set of characters. KWIC
12、索引系统接受一些行，每行有若干字，每个字由若干字符组成 Any line may be circularly shifted by repeatedly removing the first word and appending it at the end of the line. 每行都可以循环移位。重复地把第一个字删除，然后接到行末 The KWIC index system outputs a listing of all circular shifts of all lines in alphabetical order.“ KWIC把所有行的各种移位情况按照字母表顺序输出, ,13,
13、2019/8/9,Key Word In Context (KWIC),Inputs: Sequence of lines Pipes and Filters Architectures for Software Systems Outputs: Sequence of lines, circularly shifted and alphabetized and Filters Pipes Architectures for Software Systems Filters Pipes and for Software Systems Architectures Pipes and Filte
14、rs Software Systems Architectures for Systems Architectures for Software, ,14,2019/8/9,Design Considerations,Change in Algorithm Eg., batch vs incremental Change in Data Representation Eg., line storage, explicit vs implicit shifts Change in Function Eg., eliminate lines starting with trivial words
15、Performance Eg., space and time Reuse Eg., sorting, ,15,2019/8/9,Solution 1,Decompose the overall processing into a sequence of processing steps. Read lines; Make shifts; Alphabetize; Print results Copy data in modules 数据在每个模块内拷贝 Determine the representation of data between neighbors. 相邻模块间约定好数据格式 U
16、sually use the same representation of data for all modules 通常完全采用相同的数据格式，也最好这样做, ,16,2019/8/9,Solution 1：Modularization,Module 1：Input Read data lines and pass to the next module 按行读取数据，传递给下一模块 Module 2：Circular Shift The first lines coming make it work 第一行数据到来后开始运作 Transmit the old and new lines to
17、 the next 把原始数据行，和新的移位后的行输出给下一模块 Module 3：Alphabetize Collect data lines, buffer. All done, begin to work 接收行数据，缓存。当数据都到达后，开始排序 Finish, output results 排序完毕，输出结果, ,17,2019/8/9,Solution 1：Modularization,Module 4：Output Called after Alphabetization 排序后被调用 Read sorted data lines, print formatted output
18、读取排序生成的数据，逐行格式化输出, ,18,2019/8/9,Architecture of Solution 1, ,19,2019/8/9,Properties of Solution 1,Concurrent partly 部分并行处理 Use lots of memory 空间消耗很大 Every modules should know the representation of data 每个模块都必须知道输入和输出的数据格式, ,20,2019/8/9,Solution 2,Decompose the overall processing into a sequence of p
19、rocessing steps. Read lines; Make shifts; Alphabetize; Print results Each step transforms the data completely. 每一步完全转换数据 Intermediate data stored in shared memory. Arrays of characters with indexes 带索引的字符数组 Relies on sequential processing 串行处理, ,21,2019/8/9,Solution 2：Modularization,Module 1: Input
20、Reads data lines and stores them in “core”. Storage format: 4 chars/machine word; array of pointers to start of each line. Module 2: Circular Shift Called after Input is done. Reads line storage to produce new array of pairs: (index of 1st char of each circular shift, index of original line) Module
21、3: Alphabetize Called after Circular Shift. Reads the two arrays and produces new index., ,22,2019/8/9,Solution 2：Modularization,Module 4: Output Called after alphabetization and prints nicely formatted output of shifts Reads arrays produced by Modules 1 & 3 Module 5: Master Control Handles sequenci
22、ng of other modules Handles errors, ,23,2019/8/9,Architecture of Solution 2, ,24,2019/8/9,Properties of Solution 2,Batch sequential processing. Uses shared data to get good performance. 用共享数据获得性能 Processing phases handled by control module. So has some characteristics of main program subroutine orga
23、nization. Depends critically on single thread of control. Shared data structures exposed as inter-module knowledge. 共享数据的结构是所有模块必须知道的 Design of these structures must be worked out before work can begin on those modules. 数据结构的设计必须在其他模块设计开始之前进行, ,25,2019/8/9,Solution 3,Maintain same flow of control, b
24、ut Organize solution around set of abstract data type managers (objects): for initial lines shifted lines alphabetized lines Each manager: handles (and hides) the representation of the data provides a procedural interface for accessing the data, ,26,2019/8/9,Solution 3: Modularization,Module 1: Line
25、 storage Manages lines and characters; procedural interface Storage format: not specified at this point Module 2: Input Reads lines of data and stores using “Characters” ADT Module 3: Circular Shift Provides access functions to characters in circular shifts Requires “setup” as initialization after I
26、nput is done, ,27,2019/8/9,Solution 3: Modularization,Module 4: Alphabetize Provides index of circular shift “Alph” called to initialize after Circular Shift Module 5: Output Prints formatted output of shifted lines Module 6: Master Control Handles sequencing of other modules, ,28,2019/8/9,Architect
27、ure of Solution 3, ,29,2019/8/9,Properties of Solution 3,Module interfaces are abstract hide data representations could be array + indices, as before or lines could be stored explicitly hide internal algorithm used to process that data could be lazy or eager evaluation require users to follow a prot
28、ocol for correct use initialization, error handling Allows work to begin on modules before data representations are designed. Could result in same executable code as solution 2. according to Parnas, at least, ,30,2019/8/9,Comparisons - 1,Change in Algorithm Solution 1: permits alternatives Solution
29、2: batch algorithm hard-wired Solution 3: permits alternatives Change in Data Representation Solution 1: data formats are common among many modules or two modules Solution 2: data formats are common among many modules Solution 3: data formats are hidden, ,31,2019/8/9,Comparisons - 2,Change in Functi
30、on Solution 1: easy if adding a new filter Solution 2: easy if adding a new phase of processing Solution 3: modularization doesnt give particular help. But we can use inheritance. Performance Solution 1: Bad in space and good in speed Solution 2: Good Solution 3: Probably not as good, but might be,
31、,32,2019/8/9,Comparisons - 3,Reuse Solution 1: Poor since tied to particular data formats Solution 2: Poor since tied to particular data formats Solution 3: Better, ,33,2019/8/9,KWIC：Summary,What does this example teach us? For some quality attributes (space/time performance, change of functional fl
32、ow) shared memory can be a good architecture For other quality attributes (reuse, general modifiability, portability) ADT solution is better The ADT solution also permits a divide-and-conquer approach to software development in terms of allocation of work in terms of cognitive effort This thinking l
33、eads to (led to) object architectures., ,34,2019/8/9,Encapsulation/Information Hiding,Parnas：Hide secrets (not just representations) Booch: Objects behavior is characterized by actions that it suffers and that it requires 对象的行为体现在其接受和请求的动作, ,35,2019/8/9,Encapsulation/Information Hiding,Practically s
34、peaking: Object has state and operations, but also has responsibility for the integrity of its state 对象拥有状态和操作，也有责任维护状态 Object is known by its interface 通过接口了解对象 Object is probably instantiated from a template 对象一般是一个模板（类）的实例 Object has operations to access and alter state and perhaps generator 通过操作
35、来存取、改变和产生对象的状态 There are different kinds of objects (e.g., actor, agent, server), ,36,2019/8/9,Data Abstraction or Object-Oriented, ,37,2019/8/9,Elements of Object Architectures,Encapsulation: Restrict access to certain information 封装：限制对某些信息的访问 Interaction: Via procedure calls or similar protocol 交
36、互：通过过程调用或类似的协议 Polymorphism: Choose the method at run-time 多态：在运行时选择具体的操作 Inheritance: Keep 1 definition of shared functionality 继承：对共享的功能保持唯一的接口, ,38,2019/8/9,Elements of Object Architectures,Advantage: Reuse and maintenance: Exploit encapsulation and locality to increase productivity 复用和维护：利用封装和聚合
37、提高生产力 Problem: Management of many objects: Need structure on large set of definitions 管理大量的对象：怎样确立大量对象的结构 Note: the object architecture often closely resembles the object programming style. Is this a problem? 注意：面向对象体系结构，通常和面向对象编程风格 很类似，这是个问题吗？, ,39,2019/8/9,Finding Objects: Model the Real World,Its
38、 intuitive: if we understand the domain then we are led to a natural system structure based on the domain. 直觉很重要：如果对现实领域理解得很好，那么我们设计的体系结构就自然而然地基于现实的结构 The real world doesnt change much, so systems that model it are unlikely to change much either. 现实世界结构变化很小，按照其结构建立的体系结构变化也会很小, ,40,2019/8/9,Finding O
39、bjects: Model the Real World,Capture families of related designs through use of templates, and inheritance 通过类和继承表达同一家族的事物 But what happens when you arent modeling the real world (e.g. system for manipulating FSMs, fuzzy logic robot controller, natural language translation system)? 但是当你不是为现实世界建模时，怎么
40、办？（比如，你在写FSM管理软件，模糊逻辑机器人控制，翻译软件）, ,41,2019/8/9,Problems with Object Approaches,Managing many objects vast sea of objects requires additional structuring 对象的海洋需要额外的结构来容纳 hierarchical design suggested by Booch and Parnas Managing many interactions single interface can be limiting & unwieldy (hence, “f
41、riends”) 单一的接口能力有限并且笨拙（于是，”友元”） some languages/systems permit multiple interfaces (inner class, interface, multiple inheritance), ,42,2019/8/9,Problems with Object Approaches,Distributed responsibility for behavior makes system hard to understand interaction diagrams now used in design Capturing fam
42、ilies of related designs types/classes are often not enough design patterns as an emerging off-shoot, ,43,2019/8/9,Managing Large Object Sets,Pure O-O design leads to large flat systems with many objects Same old problems can reappear Hundreds of modules = hard to find things Need a way to impose st
43、ructure Need additional structure and discipline Structuring options Layers (which are not necessarily objects) Supplemental index Hierarchical decomposition: big objects and little objects, ,44,2019/8/9,Pipes versus Procedures, ,45,2019/8/9,Stylistic Variations,Client-server Objects are processes 进
44、程就是对象 Asymmetric: client knows about servers, but not vice versa 不对称：客户端知道服务器，反之则不然 Tiered Elaboration on client-server C/S模式的扩展 Aggregation into run-time strata 运行时层的结合 Usually small number of tiers 通常只有少量的层, ,46,2019/8/9,Stylistic Variations,Components (later) Multiple interfaces Special protocols
45、 for dynamic reconfiguration 支持动态配置的专门协议 Compound documents (later) Document is a set of embedded objects 一组嵌入的对象构成文档, ,47,2019/8/9,The Middleware View,Main features tiered system factor out 50%-90% of application independent code into shared services build on existing transport/communication infras
46、tructure,Applications,Common Application Services,Common Transport Services,invokes, ,48,2019/8/9,Reference Model for Flight Simulator, ,49,2019/8/9,Required Qualities,Real-time performance Modifiability Aircraft being simulated is frequently modified. 飞机型号经常被更换 Extend these systems so that they can
47、 simulate more and more of the real world and further improve the fidelity of the simulation 扩展系统使其能模拟更多的真实情况和让模拟的精度更高 Integrability of components large numbers often developed by different organizations, ,50,2019/8/9,History - 1,Electronic flight simulators date from the 1940s. Digital flight simulators date from the 1960s. Flight simulators were written in Fortran. These architectures were (and are) multi-process and multi-processo