@article {18590,
	title = {Network-Wide Prediction of BGP Routes},
	journal = {Networking, IEEE/ACM Transactions on},
	volume = {15},
	year = {2007},
	month = {2007/04//},
	pages = {253 - 266},
	abstract = {This paper presents provably correct algorithms for computing the outcome of the BGP route-selection process for each router in a network, without simulating the complex details of BGP message passing. The algorithms require only static inputs that can be easily obtained from the routers: the BGP routes learned from neighboring domains, the import policies configured on the BGP sessions, and the internal topology. Solving the problem would be easy if the route-selection process were deterministic and every router received all candidate BGP routes. However, two important features of BGP-the Multiple Exit Discriminator (MED) attribute and route reflectors-violate these properties. After presenting a simple route-prediction algorithm for networks that do not use these features, we present algorithms that capture the effects of the MED attribute and route reflectors in isolation. Then, we explain why the interaction between these two features precludes efficient route prediction. These two features also create difficulties for the operation of BGP itself, leading us to suggest improvements to BGP that achieve the same goals as MED and route reflection without introducing the negative side effects},
	keywords = {BGP message passing, BGP route-selection process, border gateway protocol, Message passing, multiple exit discriminator attribute, network-wide prediction, route reflectors, route-prediction algorithm, routing protocols, telecommunication network topology},
	isbn = {1063-6692},
	doi = {10.1109/TNET.2007.892876},
	author = {Feamster, Nick and Rexford,J.}
}
@conference {12347,
	title = {A Communication Interface for Multiprocessor Signal Processing Systems},
	booktitle = {Proceedings of the 2006 IEEE/ACM/IFIP Workshop on Embedded Systems for Real Time Multimedia},
	year = {2006},
	month = {2006/10//},
	pages = {127 - 132},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Parallelization of embedded software is often desirable for power/performance-related considerations for computation-intensive applications that frequently occur in the signal-processing domain. Although hardware support for parallel computation is increasingly available in embedded processing platforms, there is a distinct lack of effective software support. One of the most widely known efforts in support of parallel software is the message passing interface (MPI). However, MPI suffers from several drawbacks with regards to customization to specialized parallel processing contexts, and performance degradation for communication-intensive applications. In this paper, we propose a new interface, the signal passing interface (SPI), that is targeted toward signal processing applications and addresses the limitations of MPI for this important domain of embedded software by integrating relevant properties of MPI and coarse-grain dataflow modeling. SPI is much easier and more intuitive to use, and due to its careful specialization, more performance-efficient for the targeted application domain. We present our preliminary version of SPI, along with experiments using SPI on a practical face detection system that demonstrate the capabilities of SPI},
	keywords = {application program interfaces, Application software, coarse-grain dataflow modeling, Computer applications, Concurrent computing, Context, data flow graphs, Embedded computing, Embedded software, face detection system, Hardware, Message passing, message passing interface, MPI, Multiprocessing systems, multiprocessor signal processing system, PARALLEL PROCESSING, signal passing interface, Signal processing, SPI},
	isbn = {0-7803-9783-5},
	doi = {10.1109/ESTMED.2006.321285},
	author = {Sankalita Saha and Bhattacharyya, Shuvra S. and Wayne Wolf}
}
@article {12378,
	title = {Contention-conscious transaction ordering in multiprocessor DSP systems},
	journal = {IEEE Transactions on Signal Processing},
	volume = {54},
	year = {2006},
	month = {2006/02//},
	pages = {556 - 569},
	abstract = {This paper explores the problem of efficiently ordering interprocessor communication (IPC) operations in statically scheduled multiprocessors for iterative dataflow graphs. In most digital signal processing (DSP) applications, the throughput of the system is significantly affected by communication costs. By explicitly modeling these costs within an effective graph-theoretic analysis framework, we show that ordered transaction schedules can significantly outperform self-timed schedules even when synchronization costs are low. However, we also show that when communication latencies are nonnegligible, finding an optimal transaction order given a static schedule is an NP-complete problem, and that this intractability holds both under iterative and noniterative execution. We develop new heuristics for finding efficient transaction orders, and perform an extensive experimental comparison to gauge the performance of these heuristics.},
	keywords = {contention-conscious transaction ordering, Costs, data flow graphs, Dataflow, Delay, Digital signal processing, digital signal processing chips, Embedded system, graph-theoretic analysis, Instruments, Internet telephony, interprocessor communication, iterative dataflow graphs, iterative methods, Message passing, multiprocessor, multiprocessor DSP systems, NP-complete problem, Processor scheduling, scheduling, Signal processing, synchronization, Throughput},
	isbn = {1053-587X},
	doi = {10.1109/TSP.2005.861074},
	author = {Khandelia,M. and Bambha,N. K and Bhattacharyya, Shuvra S.}
}
@conference {17854,
	title = {Model-based OpenMP implementation of a 3D facial pose tracking system},
	booktitle = {2006 International Conference on Parallel Processing Workshops, 2006. ICPP 2006 Workshops},
	year = {2006},
	month = {2006///},
	pages = {8 pp.-73 - 8 pp.-73},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Most image processing applications are characterized by computation-intensive operations, and high memory and performance requirements. Parallelized implementation on shared-memory systems offer an attractive solution to this class of applications. However, we cannot thoroughly exploit the advantages of such architectures without proper modeling and analysis of the application. In this paper, we describe our implementation of a 3D facial pose tracking system using the OpenMP platform. Our implementation is based on a design methodology that uses coarse-grain dataflow graphs to model and schedule the application. We present our modeling approach, details of the implementation that we derived based on this modeling approach, and associated performance results. The parallelized implementation achieves significant speedup, and meets or exceeds the target frame rate under various configurations},
	keywords = {3D facial pose tracking system, application modeling, application program interfaces, application scheduling, coarse-grain dataflow graphs, Concurrent computing, data flow graphs, Educational institutions, face recognition, IMAGE PROCESSING, image processing applications, Inference algorithms, Message passing, OpenMP platform, parallel implementation, PARALLEL PROCESSING, parallel programming, Particle tracking, Processor scheduling, SHAPE, shared memory systems, shared-memory systems, Solid modeling, tracking},
	isbn = {0-7695-2637-3},
	doi = {10.1109/ICPPW.2006.55},
	author = {Saha,S. and Chung-Ching Shen and Chia-Jui Hsu and Aggarwal,G. and Veeraraghavan,A. and Sussman, Alan and Bhattacharyya, Shuvra S.}
}
@conference {17875,
	title = {High Performance Communication between Parallel Programs},
	booktitle = {Parallel and Distributed Processing Symposium, 2005. Proceedings. 19th IEEE International},
	year = {2005},
	month = {2005/04//},
	pages = {177b- 177b - 177b- 177b},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {We present algorithms for high performance communication between message-passing parallel programs, and evaluate the algorithms as implemented in InterComm. InterComm is a framework to couple parallel programs in the presence of complex data distributions within a coupled application. Multiple parallel libraries and languages may be used in the different programs of a single coupled application. The ability to couple such programs is required in many emerging application areas, such as complex simulations that model physical phenomena at multiple scales and resolutions, and image data analysis applications. We describe the new algorithms we have developed for computing inter-program communication patterns. We present experimental results showing the performance of various algorithmic tradeoffs, and also compare performance against an earlier system.},
	keywords = {Adaptive arrays, Analytical models, Chaotic communication, Computational modeling, Computer science, Data analysis, data distribution, Educational institutions, high performance communication, image data analysis, image resolution, inter-program communication patterns, InterComm, Libraries, Message passing, parallel languages, parallel libraries, parallel programming, parallel programs, performance evaluation, Wind},
	isbn = {0-7695-2312-9},
	doi = {10.1109/IPDPS.2005.243},
	author = {Jae-Yong Lee and Sussman, Alan}
}
@conference {14762,
	title = {Benchmarking a network of PCs running parallel applications},
	booktitle = {Performance, Computing and Communications, 1998. IPCCC {\textquoteright}98., IEEE International},
	year = {1998},
	month = {1998/02/16/18},
	pages = {1 - 7},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {Presents a benchmarking study that compares the performance of a network of four PCs connected by a 100 Mbit/s fast Ethernet running three different system software configurations: TCP/IP on Windows NT, TCP/IP on Linux and a lightweight message-passing protocol (U-Net active messages) on Linux. For each configuration, we report results for communication micro-benchmarks and the NAS (Numerical Aerodynamics Simulation) parallel benchmarks. For the NAS benchmarks, the overall running time using Linux TCP/IP was 12-500\% less than the Windows NT TCP/IP configuration. Likewise, the Linux U-Net based message-passing protocol outperformed the Linux TCP/IP version by 5-200\%+. We also show that, by using Linux U-Net, we are able to achieve 125 μs latency between two processes using PVM. Finally, we report that the default mathematical libraries supplied with NT (for both gcc and Visual C++) are substantially slower than the one supplied with Linux},
	keywords = {100 Mbit/s, 125 mus, Aerodynamics, Application software, communication micro-benchmarks, default mathematical libraries, Delay, Ethernet, Ethernet networks, gcc, latency, lightweight message-passing protocol, Linux, Local area networks, mathematics computing, Message passing, microcomputer applications, Microsoft Windows NT, NAS parallel benchmarks, network operating systems, Numerical simulation, parallel applications, PARALLEL PROCESSING, PC network benchmarking, performance comparison, performance evaluation, Personal communication networks, Protocols, PVM, running time, software libraries, System software, system software configurations, TCP/IP, TCPIP, Transport protocols, U-Net active messages, Visual C++},
	isbn = {0-7803-4468-5},
	doi = {10.1109/PCCC.1998.659876},
	author = {Hollingsworth, Jeffrey K and Guven, E. and Akinlar, C.}
}
@article {14770,
	title = {Critical path profiling of message passing and shared-memory programs},
	journal = {IEEE Transactions on Parallel and Distributed Systems},
	volume = {9},
	year = {1998},
	month = {1998/10//},
	pages = {1029 - 1040},
	abstract = {We introduce a runtime, nontrace-based algorithm to compute the critical path profile of the execution of message passing and shared-memory parallel programs. Our algorithm permits starting or stopping the critical path computation during program execution and reporting intermediate values. We also present an online algorithm to compute a variant of critical path, called critical path zeroing, that measures the reduction in application execution time that improving a selected procedure will have. Finally, we present a brief case study to quantify the runtime overhead of our algorithm and to show that online critical path profiling can be used to find program bottlenecks},
	keywords = {Computer Society, Concurrent computing, critical path computation, critical path profile, critical path zeroing, distributed processing, distributed shared memory systems, Instruments, Message passing, Monitoring, online algorithm, online critical path profiling, Parallel algorithms, program bottlenecks, Runtime, runtime nontrace-based algorithm, runtime overhead, shared-memory programs, system monitoring, Time measurement, Yarn},
	isbn = {1045-9219},
	doi = {10.1109/71.730530},
	author = {Hollingsworth, Jeffrey K}
}
@conference {14813,
	title = {MDL: a language and compiler for dynamic program instrumentation},
	booktitle = {, 1997 International Conference on Parallel Architectures and Compilation Techniques., 1997. Proceedings},
	year = {1997},
	month = {1997/11/10/14},
	pages = {201 - 212},
	publisher = {IEEE},
	organization = {IEEE},
	abstract = {We use a form of dynamic code generation, called dynamic instrumentation, to collect data about the execution of an application program. Dynamic instrumentation allows us to instrument running programs to collect performance and other types of information. The instrumentation code is generated incrementally and can be inserted and removed at any time. Our instrumentation currently runs on the SPARC, PA-RISC, Power 2, Alpha, and x86 architectures. Specification of what data to collect are written in a specialized language called the Metric Description Language, that is part of the Paradyn Parallel Performance Tools. This language allows platform independent descriptions of how to collect performance data. It also provides a concise way to specify, how to constrain performance data to particular resources such as modules, procedures, nodes, files, or message channels (or combinations of these resources). We also describe the details of how we weave instrumentation into a running program},
	keywords = {Alpha architecture, application program, application program interfaces, Application software, compiler generators, Computer science, dynamic code generation, Dynamic compiler, dynamic program instrumentation, Educational institutions, files, instrumentation code, Instruments, MDL, measurement, message channels, Message passing, Metric Description Language, modules, nodes, Operating systems, optimising compilers, PA-RISC, Paradyn Parallel Performance Tools, Parallel architectures, parallel programming, performance data, platform independent descriptions, Power 2 architecture, Power generation, procedures, program debugging, Program processors, running programs, Runtime, software metrics, SPARC, Specification languages, x86 architecture},
	isbn = {0-8186-8090-3},
	doi = {10.1109/PACT.1997.644016},
	author = {Hollingsworth, Jeffrey K and Niam, O. and Miller, B. P and Zhichen Xu and Goncalves,M. J.R and Ling Zheng}
}
