|
|
| Line 1: |
Line 1: |
| '''Kahn process networks''' (''KPNs'', or ''process networks'') is a [[Distributed computing|distributed]] ''[[model of computation]]'' (''MoC'') where a group of deterministic sequential [[process (computing)|processes]] are communicating through unbounded [[FIFO]] channels. The resulting process network exhibits deterministic behavior that does not depend on the various computation or communication delays. The model was originally developed for modeling [[distributed systems]] but has proven its convenience for modeling [[signal processing]] systems. As such, KPNs have found many applications in modeling [[embedded systems]], [[high-performance computing]] systems, and other computational tasks. KPNs were first introduced by [[Gilles Kahn]].
| | Hi there, I am Sophia. Some time in the past he selected to reside in North Carolina and he doesn't strategy on changing it. She is really fond of caving but she doesn't have the time recently. Invoicing is what I do.<br><br>My web-site ... [http://www.january-yjm.com/xe/index.php?mid=video&document_srl=158289 phone psychic] |
| [[File:Basic Kahn Process Network.svg|thumb|right|A Kahn process network of three processes without feedback communication. Edges A, B and C are communication channels. One of the processes is named process P.]]
| |
| | |
| ==Execution model==
| |
| KPN is a common model for describing [[signal processing]] systems where infinite streams of data are incrementally transformed by processes executing in sequence or parallel. Despite parallel processes, [[Computer multitasking|multitasking]] or [[parallel computing|parallelism]] are not required for executing this model.
| |
| | |
| In a KPN, processes communicate via unbounded [[FIFO]] channels. Processes read and write atomic [[data element]]s, or alternatively called [[Token (parser)|tokens]], from and to channels. Writing to a channel is [[Non-blocking I/O|non-blocking]], i.e. it always succeeds and does not stall the process, while reading from a channel is ''blocking'', i.e. a process that reads from an empty channel will stall and can only continue when the channel contains sufficient data items (''tokens''). Processes are not allowed to test an input channel for existence of tokens without consuming them. Given a specific input (token) history for a process, the process must be deterministic so that it always produces the same outputs (tokens). Timing or execution order of processes must not affect the result and therefore testing input channels for tokens is forbidden.
| |
| | |
| ===Notes on processes===
| |
| * A process need not read any input or have any input channels as it may act as a pure data source
| |
| * A process need not write any output or have any output channels
| |
| * Testing input channels for emptiness (or ''non-blocking reads'') could be allowed for optimization purposes, but it should not affect outputs. It can be beneficial and/or possible to do something in advance rather than wait for a channel. For example, assume there were 2 reads from different channels. If the first read would stall (wait for a token) but the second read could be read a token directly, it could be beneficial to read the second one first to save time, because the reading itself often consumes some time (e.g. time for memory allocation or copying).
| |
| | |
| ===Process firing semantics as Petri nets===
| |
| [[File:Kahn process network as Petri net.svg|thumb|right|Firing semantics of process P modeled with a [[Petri net]] displayed in the image above]]
| |
| Assuming process ''P'' in the KPN above is constructed so that it first reads data from channel ''A'', then channel ''B'', computes something and then writes data to channel ''C'', the execution model of the process can be modeled with the [[Petri net]] shown on the right. The single token in the ''PE resource'' place forbids that the process is executed simultaneously for different input data. When data arrives at channel ''A'' or ''B'', tokens are placed into places ''FIFO A'' and ''FIFO B'' respectively. The transitions of the Petri net are associated with the respective I/O operations and computation. When the data has been written to channel ''C'', ''PE resource'' is filled with its initial marking again allowing new data to be read.
| |
| | |
| ===Process as a finite state machine===
| |
| [[File:KPN as finite state machine.svg|thumb|right|A finite state machine of a process]]
| |
| A process can be modeled as a finite state machine that is in one of two states:
| |
| * Active; the process computes or writes data
| |
| * Wait; the process is blocked (waiting) for data
| |
| Assuming the finite state machine reads program elements associated with the process, it may read three kinds of tokens, which are "Compute", "Read" and "Write token". Additionally, in the ''Wait'' state it can only come back to ''Active'' state by reading a special "Get token" which means the communication channel associated with the wait contains readable data.
| |
| | |
| ==Properties==
| |
| ===Boundedness of channels===
| |
| A channel is ''strictly bounded'' by <math>b</math> if it has at most <math>b</math> unconsumed tokens for any possible execution. A KPN is ''strictly bounded'' by <math>b</math> if all channels are strictly bounded by <math>b</math>.
| |
| | |
| The number of unconsumed tokens depends on the execution order ('''scheduling''') of processes. A spontaneous data source could produce arbitrarily many tokens into a channel if the scheduler would not execute processes consuming those tokens.
| |
| | |
| A real application can not have unbounded FIFOs and therefore scheduling and maximum capacity of FIFOs must be designed into a practical implementation. The maximum capacity of FIFOs can be handled in several ways:
| |
| * FIFO bounds can be mathematically derived in design to avoid FIFO overflows. This is however not possible for all KPNs. It is an undecidable problem to test whether a KPN is strictly bounded by <math>b</math>.{{Citation needed|date=October 2010}} Moreover, in practical situations, the bound may be data dependent.
| |
| * FIFO bounds can be grown on demand (Parks, 1995)
| |
| * Blocking writes can be used so that a process blocks if a FIFO is full. This approach may unfortunately lead to an artificial deadlock unless the designer properly derives safe bounds for FIFOs (Parks, 1995). Local artificial detection at run-time may be necessary to guarantee the production of the correct output (Geilen&Basten, 2003)
| |
| | |
| ===Closed and open systems===
| |
| A ''closed KPN'' has no external input or output channels. Processes that have no input channels act as data sources and processes that have no output channels act as data sinks. In an ''open KPN'' each process has at least one input and output channel.
| |
| | |
| ===Determinism===
| |
| Processes of a KPN are [[deterministic]]. For the same input history they must always produce exactly the same output. Processes can be modeled as sequential programs that do reads and writes to ports in any order or quantity as long as determinism property is preserved. As a consequence, KPN model is deterministic so that following factors entirely determine outputs of the system:
| |
| * processes
| |
| * the network
| |
| * initial tokens
| |
| Hence, timing of the processes does not affect outputs of the system.
| |
| | |
| ===Monotonicity===
| |
| KPN processes are ''monotonic'', which means that they only need partial information of the input stream in order to produce partial information of the output stream. [[Monotonicity]] allows parallelism. In a KPN there is a [[total order]] of events{{clarify|date=October 2010}} inside a signal{{clarify|date=October 2010}}. However, there is no order relation between events in different signals. Thus, KPNs are only partially ordered, which classifies them as [[untimed model]].
| |
| | |
| ==Applications==
| |
| Due to its high expressiveness and succinctness, KPNs as underlying the model of computation are applied in several academic modeling tools to represent streaming applications, which have certain properties (e.g., dataflow-oriented, stream-based).
| |
| | |
| The open source Daedalus framework<ref>http://daedalus.liacs.nl LIACS Daedalus framework</ref> maintained by Leiden Embedded Research Center at [[Leiden university]] accepts sequential programs written in C and generates a corresponding KPN. This KPN could, for example, be used to map the KPN onto a [[FPGA]]-based platform systematically.
| |
| | |
| The [[Ambric]] Am2045 [[massively parallel processor array]] is a KPN implemented in actual silicon.<ref>Mike Butts, Anthony Mark Jones, Paul Wasson, "A Structural Object Programming Model, Architecture, Chip and Tools for Reconfigurable Computing", Proceedings of [[FCCM]], April 2007, [[IEEE Computer Society]]</ref> Its 336 32-bit processors are connected by a programmable interconnect of dedicated FIFOs. Thus its channels are strictly bounded with blocking writes.
| |
| | |
| ==External links==
| |
| | |
| [[Flow-based programming]]
| |
| | |
| ==References==
| |
| * Kahn, G. (1974). [http://www1.cs.columbia.edu/~sedwards/papers/kahn1974semantics.pdf The semantics of a simple language for parallel programming]. In Jack L. Rosenfeld (Ed.): Information Processing 74, Proceedings of IFIP Congress 74, Stockholm, Sweden, August 5–10, 1974. North-Holland, 1974, ISBN 0-7204-2803-3
| |
| * Lee, E. and Park, T. (1995). [http://ptolemy.eecs.berkeley.edu/papers/95/processNets/proceedings.pdf Dataflow Process Networks]. In Proceedings of the IEEE, volume 83, pages 773-799.
| |
| * Josephs, M.B. (2005). [http://dx.doi.org/10.1007/11423348_6 Models for Data-Flow Sequential Processes]. In: Communicating Sequential Processes, The First 25 Years, LNCS 3525, pages 85–97.
| |
| * Parks, Thomas M. (1995). [http://ptolemy.eecs.berkeley.edu/publications/papers/95/parksThesis/ Bounded Scheduling of Process Networks]
| |
| * Geilen, Marc and Basten, Twan. [http://citeseer.ist.psu.edu/geilen03requirements.html Requirements on the Execution of Kahn Process Networks]. In P. Degano, Programming Languages and Systems, 12th European Symposium on Programming, ESOP 2003, Proc., pp. 319–334. Warsaw, Poland, 7–11 April 2003. LNCS 2618. Springer, Berlin, Germany, 2003
| |
| {{Reflist}}
| |
| | |
| {{DEFAULTSORT:Kahn Process Networks}}
| |
| [[Category:Models of computation]]
| |
Hi there, I am Sophia. Some time in the past he selected to reside in North Carolina and he doesn't strategy on changing it. She is really fond of caving but she doesn't have the time recently. Invoicing is what I do.
My web-site ... phone psychic