So, in this lecturewe will focus on the interface a design of engineering systems. As you know everysystem has got many sub systems and sub systems, components and then this CIs or theconfiguration items, so this the system need to interact with the external systems as wellas within the system we need to have interaction between subsystems and componentsand configuration items.So, these interactions are taking place through the interfaces. So, we can have variousinterfaces with in the system. You can have a mechanically interface, you can have anelectrical interface or you can have a communication interface. So, all these interfacesneed to be provided in such a with that we get proper communication we get have anintegral communication the integrity of the message is not lost or there is proper passingof messages between the systems and there is proper priority for systems to interact withother systems and communicate messages. So, all these things are basically design usingthe interfaces. So, interface design becomes one of them most important aspect ofengineering system were we ensure that the communication between various systems areproper and they do not lead to failures within the system.If you look at the history of engineering systems you can see there are many failures ofengineering system because of communication failure or the interface failure within thesystem. We will see one example like that to show the important of interface design andthen we discuss about the various kind of the interface to be provider, but are thedifferent properties for this interfaces and what are the different standards to be used forinterface design.
(Refer Slide Time: 02:14)
So, as I mentioned earlier this is the fifth step in the engineering system design where wediscussed about the first four stages basically the system level design problem, systemfunction architecture, physical architecture and the operation architecture. So, wecompleted all these four and the next one is the interface architecture development.So, as I mentioned earlier will take a case study from the history of engineering systemfailures and then see how important is the interfaces in the success of an engineeringsystem.(Refer Slide Time: 02:48)
This case studies from the a path finder which was deployed to the surface of a Mars forlanding on 4th July 1997 it was a great success in many ways.So, all there was to the tremendous success from this particular project, but there was anissue when it was initially launched and then it was being used it was found that the totalsystem resets were taking place once in a while. That is few days into the machineoperators on the ground realized that there is a total system reset taking place within thesystem without any particular reason or without them able to identify what actually wasreason for this and then an analysis was carried out. And then it was found that there wasa shared memory interface which was used as the system interface between varioussubsystems. So, there are many subsystems with in the path finder and there was inarchitecture called shared memory interface was used for interfacing this subsystems.And there was a mutex or mutual exclusion lock were employed to give an activityaccess to the interface.So, whenever a particular subsystems wants to access these particular interface they needto use a mutex, the mutually exclusion locks and that is to be activated in order to get theaccess to a communication interface.(Refer Slide Time: 04:11)
So, this was one of the problem was actually lying in this interface. So, there were manysubsystem in the path finder and one of the system was meteorological data or it isactually collection of data from various sensors and passing it to the main system. So,
there this data was. So, voluminous that the activity had to obtain and release mutexesseveral times before it was finished.So, it was a very voluminous data and there was the time duration for transferring of thisdata was very a long therefore, this particular subsystem had to release the mutex manytimes because of the long the voluminous data and then before completing a particulartransactions. And at the same time there was another process the long running mediumpriority communication activity. So, this was a medium priority activity thecommunication activity would in frequently interrupt the metrological activity during itspause and gain control of the interface.So, this was what does happening. So, the metrological data was being a transferred atthe same time the communication interface, the communication activity will interruptthis particular transmission and then take control of the communication interface andthen start transferring data. So, these two are actually creating the problem in thecommunication. So, duration of these two task were sufficiently long to invoke awatchdog timer that was employed to ensure that the high priority bus management taskwas executing appropriately.So, there was a bus management task which had got a high priority and particular task ofthis system is to ensure that everything is functioning properly and whenever there is aproblem it will try to eliminate that error or to try to recover from that error. So, thesufficiently long these two tasks basically the meteorological data as well as thecommunication interface they were actually too long and often the watchdog timer willfind that something is wrong with the system because it was not able to access thecommunication interface it was not able to get the a required data to ensure the a healthof the system. So, at this time when the high priority bus management task was executingto check this particular task was a executing or not, it was often found that there wassome problem or this particular system was identifying that there is an issue and it wastrying to reboot the system.So, in such rare cases the watch dog timer initiated a total system reset to prevent anyfurther damage to the system. So, when this two particular sub systems were trying tocommunicate and then trying to get control of the mutex the priority bus managementtask was not able execute properly and that actually of resultant into a kind of a problem
or kind of a error with identified by the system the health check. And that actually wasleading to a total a system reset to ensure that or assuming that there is an error in thesystem and it was trying to ensure that it is not go leading to major errors. So, it will gofor a total system reset. So, this was what was happening in the system.So, there were many subsystems it was interacting and there was some kind of a healthmonitoring as well as the error identification of error and eliminating the error. So, thesesystem were actually conflicting and then trying to take control of the system or thecommunication system at that time total reset were taking place.(Refer Slide Time: 07:29)
So, the jet propulsion lab engineers ran a pathfinder replica on earth till they reached thereset situation. So, you know to find out what actually is happening in the system theengineers ran a replica on earth till they reach the reset situation then identify theproblem that there is a problem with the priorities of each tasks or some task need to beprioritized so that the priority task will always get the mutex and then that will not leadto a error situation.So, there it was one that the interface software which was used for the interface had beenprogrammed without a feature called priority inheritance. So, this particular feature ofpriority inheritance which actually a give some particular priority and that inherit thatpriority for different subsystems that was not there and the engineers uploaded a short Cprogram and pathfinder did not experience any more system pieces. The solution was
very simple, but identification of the problem and then solving it was the difficult taskbecause they had to run the replica on earth and then find out what led to the problemand then they solved the problem.(Refer Slide Time: 08:34)
So, this actually shows that interfaces are very important in engineering systems in evena minor error can actually lead to a total reset or the failure of the complete system andtherefore, it is necessary for the system designers to look at the interfaces in detail andhave a formal procedure to design the interfaces and ensure that interfaces functionproperly and it actually provides the necessary communication between different somesystems.So, let us look at how we actually define the interfaces and how do you actually look atthe various aspects of the design of interfaces. As you know interfaces are commonfailure points in the system, so most of the possibility of failure actually comes from theinterfaces, which is defined as a connection resource for hooking to another systemsinterface. So, the interface is basically a resource for hooking to another systemsinterface or subsystems interface when it is an external system then it is another systemsinterface or for hooking one systems component to another that is an internal interface.So, you can have an internal interface or an external interface. An external interface isbasically used for a system to hook onto another system; an internal interface is used forhooking to the same systems components for the configuration items.
Important aspects of interface design are basically looking at these interfaces identifyingthe important interfaces in the system you look at the external interfaces required andinternal interfaces required. For example, even you consider the elevator or any othersystem you can actually identify many interfaces one may be with external system. So,the elevator need to interact with the passengers is an external system and that actuallywe need to have different kinds of interfaces, the communication interface in terms ofdata input and some other kind of interface with the maintenance people or interface withthe emergency services. So, all these kinds of interfaces need to be identified in advance.So, that is the first task, identify all the interfaces external. Then internal interface also,in internal interface can be identified using the functional structure or the physicalarchitecture of the system. When we do A-0 method of functional decomposition andthen identifying all the functions this actually will give us different inputs and outputsfrom different sub functions and the that will tell us what kind of interfaces are neededbetween these sub functions.So, when we convert that into in a physical architecture then we will know that thesecomponents which actually provide the functions need the particular kind of interface interms of digital data going digital data interface or analog data interface or some kind ofa mechanical interface. So, this is the first step in identifying or designing the systeminterface or interface design of systems.And once we identify the interfaces the next task is basically to allocate the inputs andoutputs for the interfaces. So, every interface like every system design task will try toidentify the inputs and outputs for the system. So, what kind of input is coming to thesystem whether it is a digital data input or analog input or what kind of data structure isthere for that particular input, what is the size of the input, what kind of transmissionspeed is needed.So, all these things need to be identified in the inputs and outputs for the interface andthen we derive the interface requirement interface requirements in terms of the systemshould be able to transmit the digital output from one point to another point or it has toaccept the digital requests from passenger or digital data to be requested the systemshould be able to receive the digitized information from one particular system. So, thatkind of interface requirement can be developed after identifying the interfaces.
And then exploring the alternative interface architecture, so there can be manyarchitectures for interface. So, we need to look at what kind of an architecture will be thebest for this particular system. So, we will discuss about various architectures for theinterfaces, so from these architectures we need to choose a most suitable interface. So,when we discuss about interface design we will actually look at only and othercommunication interfaces the mechanical interface and other physical interfaces neededwithin the system will not be discussed here because those are mainly coming from thephysical architecture.So, whenever we identify the particular configuration for the interface or the alternateinterface architectures we basically look at the alternatives and then the physical systemdesign of that will be a separate task. So, we do not discuss about the physical interfaceswe will be looking more on the communication interfaces to be provided for the system.(Refer Slide Time: 13:51)
So, the main requirements for an interface is the important performance requirements arebasically in terms of performance there are throughput and response time are twoimportant parameters in terms of for interfaces. So, what is the data I can transmit andwhat is the response time for this transmission, these are the two parameters we need tolook at when we design an interface.And apart from that we need to look at the fidelity of the data that is the integrity of thedata whatever we transmit from one point to another point should reach that point
without any damage without any change; that means, no changes should be there in thedata during transmission. So, whatever we transmit from one point to another point itshould reach the without any variation. So, that is the integrity of the data transmissionthat is also that is one of another important factor to be considered in the design ofinterfaces.And then deliver every item placed on the interface. So, the interface should deliverevery item placed at the interface. So, it is not filtered out or it should not lose because ofexternal interference or any other factors there is not be any loss of data in at theinterface for every item place that the interface should be transmitted.And the other one is basically it should detect faults and recover gracefully. So,whenever there is a fault or in a system that is error happening the system should becapable of coming out of that situation gracefully that is without causing any otherdamage to the other systems. So, whenever there is a problem identified by the interfaceit should try to minimize the damage and eliminate that particular damage and then startcontinue to function normally without affecting other system performances. So, these arethe important requirements for interface.So, whenever we design interface we look at these parameters these factors and thenensure that whatever the architecture we choose for the interface basically meets all theserequirements. So, that there are no problems in the interface whatever the data we wantto transmit is getting transmitted and there now, there is in error the system tries to comeout of it gracefully and continue to perform without much problem for the whole system.
(Refer Slide Time: 16:11)
Let us look at the some of the, and generic interface architecture there are differentarchitectures available depending on the situation we need to choose this architecture.So, there are basically three generic interface architecture the first one is known asmessage passing. So, this is a something like a mail delivery that predictably occurs onceor twice a day allowing the receivers to access it immediately or it until a moreopportune time. So, it is a very predictable data exchange. So, the system will beknowing that what will be the frequency at which that data will be transmitted. So, everyhour or every second depending on the subsystems the system can actually identify whatis the frequency of this data transmission and it will continue to transmit this data and thereceiver can actually access it immediately or actually can access it at a later stage. So,this kind of architecture is the message passing. We will see the details of messagepassing bit later.The other one is shared memory architecture this is something like a meeting orconference in which only one person speaks and conveys relatively compact messageswhere all can hear what he said, but yet are restrained from other productive work. Hereit is unlike the message passing it is like where everyone can speak, but not at the sametime. So, one person can actually speak and others can listen and other whenever oneperson is speaking all other only others can what can do is only to listen to that one. So,they cannot really interact. So, it is only one way communication from one person. So,
he passes the message to a shared memory and others can actually get it from thatmemory shared memory. So, that is the shared memory architecture.And the last one is the network architecture which is very common. So, it is like atelephone conversation that can involve message. So, widely varying lengths and can beinstigated at almost any time. So, this is network which is very common in most of thesystems. So, here we can actually pass messages and different people can hear and thenothers can also pass messages we can have different architectures and network itselfdepending on the requirement can have one to one or you can have one too many or youcan have redundant communication and network or loops that is the networkarchitecture.(Refer Slide Time: 18:32)
Let us just see the architecture of the message passing. So, that was the first one wediscussed the message passing architecture. This is basically predictable exchange ofinformation.So, as I mentioned the predictable exchange of information whenever. Now, there is apredictable exchange of information we can use the message passing architecture. This iscommonly found as an internal interface in system. So, this cannot be normally used hasbetween the system and the external system because the external system the interactionbetween system and external system may not be always predictable, but within thesystem the system designers will be knowing what kind of data to be transmitted
between the subsystems. So, in that case we can go for a message passing architecturebecause of the predictable nature. And every message here will be consisting of aprotocol and data segment. So, the message to be passed between the elements of thesystem of the subsystems will be having a message protocol and a data segment.The protocol segment will include us the size of the message and address of the node toreceive the message. So, when we have multiple nodes in the system, so the message willbe having a protocol which will actually tell the size of the message and address of thenode to receive the message and then other segments will be having the data segmentsalso. So, this actually the first segment will tell to whom the particular message isaddressed and then what is the size of the message and the second, but will give actualmessage.And the message passing protocol or the communication the process of communicationin message passing architecture is basically one nodes must will control over thecommunication channel by a priority scheme implemented by the system.(Refer Slide Time: 20:02)
So, there will be many people who using the same interface. So, one node must wincontrol over the communication channel by a priority scheme. So, this priority scheme isdesign by the designers. So, the system designers will be knowing which one is moreimportant and how do we actually prioritize between different nodes in the system and
based on that priority one node will take over the control of the interface. So, this nodewill be able to transfer the data once it has got the control over the nodes.And the winning node becomes the master and sends a protocol segment to the intendedreceiving node. So, once the node takes. So, the control over the network or the interfaceit actually provides in becomes a master and sends a protocol segment to the intendedreceiving node called slave. So, now, it becomes the master and all of that becomeslaves, then it will send a protocol segment to the receiving node which is the slave here.And once the slave node notify the master that the protocol segment was receivedsuccessfully. So, once the master sends a protocol the receiver receives it and then givesan acknowledgement that the protocol has been received successfully and once thathappens the master sends the data segment to the slave.So, basically the master will be sending the data to the slave or the other way if the slavecan actually give a segment saying that the data has been received. So, the master canactually send the data to the slave and then slave will give an acknowledgment. So, thisis the normal process of communication in message passing architecture. So, there willbe multiple nodes, one node will get the control of interface and then that node becomesthe master and then it sends a protocol segment to the slave and the slave accepts thatprotocol and confirm the received of the protocol and once that is confirmed mastersends that data and then the play acknowledges a received of data.So, that particular cycle is over and then the node will actually give you the control themaster surrenders control of the communication channel. So, once that the predictableexchange is over and master will just surrender the control of the communicationchannel. So, that any other node can actually take over that particular become a masteragain based on a priority scheme. So, this is the way how the communication takes placein message passing architecture.
(Refer Slide Time: 22:49)
And this is the most preferred application of message passing for system that can definea predictable message transmission scheduled upon initialization. So, message passing asI mentioned can be used for predictable data exchange. So, whenever system initiatesand there are predictable data exchanges for such systems only this is most appropriate.So, the system designers will be knowing how the system works and what kind ofinterface data transfers takes place, so based on that we can go for this particularmessage passing architecture.And here the update rates are on the order of 0.01 to 1 second. So, that is the update ratein transmission and message passing is not preferred where substantial portions of thetraffic include asynchronous communication. So, when there is asynchronouscommunication where it is not predictable or it not happening in the periodic interval andthat is a very substantial part of the communication then it is very difficult to implementmessage passing architecture because it is barely used for predictable data exchangeonly.So, whenever there is an asynchronous data transmission we go for the next one which iscalled the shared memory architecture.
(Refer Slide Time: 23:55)
Here in shared memory architecture asynchronous communication requests are handled.So, unlike the message passing where it is predictable data exchange in shared memorywe go for a synchronous communication. So, whenever there is an asynchronouscommunication request with go for the shared memory architecture. Here a fast accessstorage device typically a memory device is used. So, this is the shared memory basicallyshared memory is shared by different nodes, so a fast access storage device that is usedas the memory device.(Refer Slide Time: 24:36)
In the communication process in this is basically a processor generates a read or writerequest for another address in shared memory. So, the shared memory will be having allthe address of those nodes which are using the particular shared memory. So, processorgenerates a read or write request for another address in shared memory whichever systemwants to transmit a data to a particular another node. So, it actually generates a read orwrite request for that particular address.The current owner of this variable is notified of the request. So, one variable may beused by some other owner or some others are using the particular variable then this willbe notified and to that user and the memory of that current owner is dumped to theshared memory. So, whoever wants to write a particular variable suppose there are someglobal variables to be updated like temperature or pressure or some other data to beupdated in the system in that case whoever wants to write or update that data will send amessage to the shared memory requesting for access to that particular variable. So, someother system may be using that variable. So, that particular subsystem will be intimatedabout this particular request and then if it is possible to dump that particular variable thenthe present user will dump that variable to the shared memory and then the read or writerequest of the processor is completed with a data transfer.So, once that is a made available to the requester then the data transfer will take placeand again the variable will be available with the press the owner till the next free casethis owner variable will be kept there and whenever there is another request for this datathis particular variable that will be a dumped again to the memory and can be used byother users. So, this is the normal communication process in shared memory architecture.So, as I mentioned there is a memory device a fast access memory device you stay hereand whenever a particular user wants to access a variable in the shared memory it gives anotification. And then whoever is using that variable will dump that variable to theshared memory system is requested for that variable can read or write the data and thenagain complete the data transfer and then release that variable or you can keep is thevariable till the next request comes. So, this is the normal way of communication inshared memory architecture.
So, here actually can be asynchronous because I mean there are there is no particulartime interval on which the particular data comes. So, whenever any system wants toaccess the variable and then transfer the data.(Refer Slide Time: 27:23)
So, the problems with this shared memory architecture is that the performance of thisdegrades substantially if the requested information is not in the cache memory of theinterface. So, whenever that particular information or the variable is not available in thecache memory then it becomes a problem and the performance degrades because it willwait for that data to come or this activity is blocked until the required variables areretrieved.So, until that the particular request is completed do not be able to do any other task. So,whenever a particular variable or a task is not this not available within the cache memoryit has to get it from some other users then it will wait till that variable is made availableand then only it will go for the next task. So, that the actually this may reduce theperformance sometimes. So, that is one of the problem with the shared memoryarchitecture. And it works invest in highly parallel software applications in which the global data ofeach application must be accessed frequently by the application and infrequently ornever by other applications. So, this is best architecture for parallel computationapplications parallel software applications where the software will be having some global.variables it will be used by other subsystems, but it has to update the data frequently. So,in this case this particular application can actually access it frequently and then update it,but others may or may not be using it. So, that kind of situation this is well suited.But in the cases where others are also using then that first problem will be there like theedges to wait till that is made available to the first application, so that may degrade theperformance.