@phdthesis {Simula.simula.2596,
	title = {Parallel Programming Models and Run-Time System Support for Interactive Multimedia Applications},
	year = {2013},
	month = {March},
	school = {University of Oslo},
	type = {phd},
	author = {Beskow, Paul}
}
@misc {Simula.simula.668,
	title = {Distributed Real-Time Processing of Multimedia Data With the P2G Framework},
	year = {2011},
	month = {April},
	abstract = {P2G is a framework designed to integrate concepts from modern batch processing frameworks into the world of real-time multimedia processing, where we seek to scale transparently with the available resources. P2G consists of a compiler and run-time that analyzes dependencies dynamically and merges or splits kernel instances based on resouce availability and performance monitoring.},
	author = {Beskow, Paul and Espeland, H{\r a}vard and H{\r a}kon Kvale {Stensland} and Preben N. {Olsen} and St{\r a}le B. {Kristoffersen} and Espen Angell {Kristiansen} and Griwodz, Carsten and Halvorsen, P{\r a}l}
}
@inproceedings {Simula.simula.686,
	title = {P2G: a Framework for Distributed Real-Time Processing of Multimedia Data},
	journal = {Proceedings of the International Workshop on Scheduling and Resource Management for Parallel and Distributed Systems (SRMPDS) - The 2011 International Conference on Parallel Processing Workshops},
	year = {2011},
	month = {September},
	pages = {416-426},
	publisher = {IEEE},
	type = {Workshop},
	abstract = {The computational demands of multimedia data processing are steadily increasing as consumers call for progressively more complex and intelligent multimedia services. New multi-core hardware architectures provide the required resources, but writing parallel, distributed applications remains a labor-intensive task compared to their sequential counter-part. For this reason, Google and Microsoft implemented their respective processing frameworks MapReduce, as they allow the developer to think sequentially, yet benefit from parallel and distributed execution. An inherent limitation in the design of these processing frameworks is their inability to express arbitrarily complex workloads. The dependency graphs of the frameworks are often limited to directed acyclic graphs, or even pre-determined stages. This is particularly problematic for video encoding and other algorithms that depend on iterative execution. With the Nornir runtime system for parallel programs, which is a Kahn Process Network implementation, we addressed and solved several of these limitations. However, it is more difficult to use than other frameworks due to its complex programming model. In this paper, we build on the knowledge gained from Nornir and present a new framework, called , designed specifically for developing and processing distributed real-time multimedia data. P2G supports arbitrarily complex dependency graphs with cycles, branches and deadlines, and provides both data- and task-parallelism. The framework is implemented to scale transparently with available (heterogeneous) resources, a concept familiar from the cloud computing paradigm. We have implemented an (interchangeable) P2G to ease development. In this paper, we present a proof of concept implementation of a P2G execution node and some experimental examples using complex workloads like Motion JPEG and K-means clustering. The results show that the P2G system is a feasible approach to multimedia processing.},
	isbn = {978-0-7695-4511-0},
	author = {Espeland, H{\r a}vard and Beskow, Paul and H{\r a}kon Kvale {Stensland} and Preben N. {Olsen} and St{\r a}le B. {Kristoffersen} and Griwodz, Carsten and Halvorsen, P{\r a}l},
	editor = {Sheu, Jang-Ping and Wang, Cho-Li}
}
@inproceedings {Simula.simula.748,
	title = {Processing of Multimedia Data Using the P2G Framework},
	journal = {Proceedings of the 19th ACM international conference on Multimedia},
	year = {2011},
	pages = {819-820},
	publisher = {ACM},
	type = {Conference},
	abstract = {In this demo, we present the P2G framework designed for processing distributed real-time multimedia data. P2G supports arbitrarily complex dependency graphs with cycles, branches and deadlines. P2G is implemented to scale transparently with available resources, i.e., a concept familiar from the cloud computing paradigm. Additionally, P2G supports heterogeneous computing resources, such as x86 and GPU processing cores. We have implemented an interchangeable P2G kernel language which is meant to expose fundamental concepts of the P2G programming model and ease the application development. Here, we demonstrate the P2G execution node using a MJPEG encoder as an example workload when dynamically adding and removing processing cores.},
	isbn = {978-1-4503-0616-4},
	author = {Beskow, Paul and H{\r a}kon Kvale {Stensland} and Espeland, H{\r a}vard and Espen Angell {Kristiansen} and Preben N. {Olsen} and St{\r a}le B. {Kristoffersen} and Griwodz, Carsten and Halvorsen, P{\r a}l},
	editor = {Sundaram, Hari and Feng, Wu-chi and Sebe, Nicu}
}
@article {Simula.mpg.30,
	title = {The Nornir Run-Time System for Parallel Programs Using Kahn Process Networks on Multi-Core Machines - a Flexible Alternative to MapReduce},
	journal = {The Journal of Supercomputing},
	number = {Online first},
	year = {2010},
	note = {In print: January 2013, Volume 63, Issue 1, pp 191-217},
	pages = {1-27},
	abstract = {Even though shared-memory concurrency is a paradigm frequently used for developing parallel applications on small- and middle-sized machines, experience has shown that it is hard to use. This is largely caused by synchro- nization primitives which are low-level, inherently nondeterministic, and, consequently, non-intuitive to use. In this paper, we present the Nornir run-time system. Nornir is comparable to well-known frameworks such as MapReduce and Dryad that are recognized for their efficiency and simplicity. Unlike these frameworks, Nornir also supports process structures containing branches and cycles. Nornir is based on the formalism of Kahn process networks, which is a shared-nothing, message-passing model of concurrency. We deem this model a simple and deterministic alternative to shared-memory concurrency. Experiments with real and synthetic benchmarks on up to 8 CPUs show that per- formance in most cases scales almost linearly with the number of CPUs, when not limited by data dependencies. We also show that the modeling flexibility allows Nornir to outperform its MapReduce counter-parts using well-known benchmarks.},
	doi = {10.1007/s11227-010-0503-2},
	author = {Vrba, Zeljko and Halvorsen, P{\r a}l and Griwodz, Carsten and Beskow, Paul and Espeland, H{\r a}vard and Johansen, Dag}
}
@article {Simula.mpg.10,
	title = {Reducing Game Latency by Migration, Core-Selection and TCP Modifications},
	journal = {International Journal of Advanced Media and Communication (IJAMC)},
	volume = {4},
	number = {4},
	year = {2010},
	note = {Special issue on selected papers from NetGames},
	pages = {343-363},
	abstract = {Massively multi-player online games (MMOGs) have stringent latency requirements and handle large numbers of concurrent players. To support these conflicting requirements, it is common to divide the virtual environment into virtual regions, and spawn multiple instances of isolated game areas; to serve multiple distinct groups of players. As MMOGs attract players across the world, dispersing these regions and instances on geographically distributed servers is plausible. With Ginnungagap, we present the prototype implementation and evaluation of functionality for migrating objects to support dynamic re-distribution of game state; with a distributed name server efficiently maintaining references to migrated objects. Core selection algorithms, using players latencies, can then locate an optimal placement for a given region or instance. The variance of the measured latencies (and core selection algorithm) are reduced by enabling our TCP modifications for latency reduction for non-greedy streams. Correspondingly, we anticipate a decrease in aggregate latency for the affected players.},
	doi = {10.1504/IJAMC.2010.036835},
	author = {Beskow, Paul and Petlund, Andreas and Erikstad, Geir and Griwodz, Carsten and Halvorsen, P{\r a}l}
}
@inproceedings {Simula.nd.471,
	title = {Evaluating Ginnungagap: a Middleware for Migration of Partial Game-State Utilizing Core-Selection for Latency Reduction},
	journal = {Proceedings of the workshop on Network and System Support for Games (NetGames)},
	year = {2009},
	month = {November},
	pages = {1-6},
	publisher = {IEEE},
	type = {Workshop},
	abstract = {Massively multi-player online games (MMOGs) have stringent la- tency requirements and must support large numbers of concurrent players. To handle these conflicting requirements, it is common to divide the virtual environment into virtual regions, and spawn multiple instances of isolated game areas (known as dungeons or instances) to serve multiple distinct groups of players. As MMOGs attract players from all around the world, it is plausible to disperse these regions and instances on geographically distributed servers. Core selection algorithms can then be applied to locate an opti- mal server for placing a region or instance, based on player la- tencies. Functionality for migrating objects supports this objective, with a distributed name server ensuring that references to the moved objects are efficiently maintained. As a result, we anticipate a decrease in aggregate latency for the affected players. With GINNUNGAGAP we present the implementation and evaluation of a middleware that combines these ideas and present its feasibility.},
	isbn = {978-1-4244-5604-8},
	doi = {10.1109/NETGAMES.2009.5446220},
	author = {Beskow, Paul and Erikstad, Geir and Halvorsen, P{\r a}l and Griwodz, Carsten},
	editor = {Abdallah, Maha}
}
@article {Simula.ND.311,
	title = {Improving SCTP Retransmission Delays for Time-Dependent Thin Streams},
	journal = {Multimedia Tools and Applications},
	volume = {45},
	number = {1-3},
	year = {2009},
	note = {Special Issue on Massively Multiuser Online Gaming Systems and Applications},
	pages = {33-60},
	abstract = {A large number of network services rely on IP and reliable transport pro- tocols. For applications that provide abundant data for transmission, loss is usually handled satisfactorily, even if the application is latency-sensitive. For data streams where small packets are sent intermittently, however, applications can occasionally experience extreme latencies. As it is not uncommon that such thin-stream ap- plications are time-dependent, any unnecessarily induced delay can have severe conse- quences for the service provided. It has been shown that TCP has several shortcomings with respect to the latency requirements of thin streams because of the way it handles retransmissions. As such, an alternative to TCP may be SCTP, which was de- veloped to meet the requirements of signalling transport. SCTP has subsequently been considered more appropriate than TCP for congestion-controlled streaming, primarily because SCTP maintains packetboundaries and intrinsically supports partial reliabil- ity. In this paper, we evaluate the Linux-kernel SCTP implementation in the context of thin streams. To address the identi{fi}ed latency challenges, we propose sender-side only enhancements that reduce the application-layer latency in a manner that is compatible with unmodi{fi}ed receivers. These enhancements can be switched on by applications and are used only when the system identi{fi}es the stream as thin. To evaluate the latency performance, we have performed several tests over various real networks and over an emulated network, varying parameters like RTT, packet loss and amount of competing cross tra{ffi}c. When comparing our modi{fi}cations with SCTP on Linux and FreeBSD and TCP New Reno, our results show great latency improvements and indicate the need for a separate handling of thin and thick streams.},
	doi = {10.1007/s11042-009-0286-8},
	author = {Petlund, Andreas and Beskow, Paul and Pedersen, Jon and Espen S{\o}g{\r a}rd {Paaby} and Griwodz, Carsten and Halvorsen, P{\r a}l}
}
@inproceedings {Simula.ND.321,
	title = {Kahn Process Networks Are a Flexible Alternative to MapReduce},
	journal = {Proceedings of 11th IEEE International Conference on High Performance Computing and Communications (HPCC)},
	year = {2009},
	pages = {154-162},
	publisher = {IEEE Computer Society},
	type = {Conference},
	abstract = {Experience has shown that development using shared-memory concurrency, the prevalent parallel programming paradigm today, is hard and synchronization primitives nonintuitive because they are low-level and inherently nondeterministic. To help developers, we propose Kahn process networks, which are based on message-passing and shared-nothing model, as a simple and flexible tool for modeling parallel applications. We argue that they are more flexbile than MapReduce, which is widely recognized for its efficiency and simplicity. Nevertheless, Kahn process networks are equally intuitive to use, and, indeed, MapReduce is implementable as a Kahn process network. Our presented benchmarks (word count and k-means) show that a Kahn process network framework permits alternative implementations that bring significant performance advantages: the two programs run by a factor of up to \sim 2.8 (word-count) and \sim 1.8 (k-means) faster than their implementations for Phoenix, which is a MapReduce framework specifically optimized for executing on multicore machines.},
	isbn = {978-0-7695-3738-2},
	doi = {10.1109/HPCC.2009.46},
	author = {Vrba, Zeljko and Beskow, Paul and Halvorsen, P{\r a}l and Griwodz, Carsten}
}
@inproceedings {Simula.ND.397,
	title = {The Nornir Run-Time System for Parallel Programs Using Kahn Process Networks},
	journal = {Proceedings of 6th International Conference on Network and Parallel Computing (NPC)},
	year = {2009},
	pages = {1-8},
	publisher = {IEEE Computer Society},
	type = {Conference},
	abstract = {Shared-memory concurrency is the prevalent paradigm used for developing parallel applications targeted towards small- and middle-sized machines, but experience has shown that it is hard to use. This is largely caused by synchronization primitives which are low-level, inherently nondeterministic, and, consequently, non-intuitive to use. In this paper, we present the \textit{Nornir} run-time system. Nornir is comparable to well-known frameworks like MapReduce and Dryad, but has additional support for process structures containing cycles. It is based on the formalism of Kahn process networks, which we deem as a simple and deterministic alternative to shared-memory concurrency. Experiments with real and synthetic benchmarks on up to 8 CPUs show that performance in most cases improves almost linearly with the number of CPUs, when not limited by data dependencies.},
	isbn = {978-0-7695-3837-2},
	author = {Vrba, Zeljko and Halvorsen, P{\r a}l and Griwodz, Carsten and Beskow, Paul and Johansen, Dag}
}
@article {Simula.ND.327,
	title = {The Partial Migration of Game State and Dynamic Server Selection to Reduce Latency},
	journal = {Multimedia Tools and Applications},
	volume = {45},
	number = {1-3},
	year = {2009},
	note = {Special Issue on Massively Multiuser Online Gaming Systems and Applications},
	pages = {83-107},
	abstract = {Massively multi-player online games (MMOGs) have stringent latency requirements and must support large numbers of concurrent players. To handle these conflicting requirements, it is common to divide the virtual environment into virtual regions. As MMOGs are world-spanning games, it is plausible to disperse these regions on geographically distributed servers. Core selection can then be applied to locate an optimal server for placing a region, based on player latencies. Functionality for migrating objects supports this objective, with a distributed name server ensuring that references to the moved objects are maintained. As a result we anticipate a decrease in the aggregate latency for the affected players. The core selection relies on a set of servers and measurements of the interacting players latencies. Measuring these latencies by actively probing the network is not scalable for a large number of players. We therefore explore the use of latency estimation techniques to gather this information.},
	doi = {10.1007/s11042-009-0287-7},
	author = {Beskow, Paul and Vik, Knut-Helge and Halvorsen, P{\r a}l and Griwodz, Carsten}
}
@inproceedings {Simula.ND.225,
	title = {Latency Reduction by Dynamic Core Selection and Partial Migration of Game State},
	journal = {Proceedings of Workshop on Network and Systems Support for Games (NetGames)},
	year = {2008},
	month = {October},
	pages = {79-84},
	publisher = {ACM},
	type = {Workshop},
	abstract = {Massively multi-player online games (MMOGs) require low latency while supporting a large number of concurrent players, often sharing one worldwide instance of the game. As these are conflicting requirements, a common way of distributing load is by dividing the virtual environment into virtual regions. As MMOGs are world-spanning games, it is plausible to disperse these regions on geographically distributed servers. As such, we propose the use of core selection for finding an optimal server for placing a region, and support for migrating the game state to that server. The first goal relies on a set of servers and measurement of the interacting players latencies. In locating an optimal server, we anticipate a decrease in the overall latency for the majority of players. This reduction occurs by migrating the region to a server closer in proximity to the majority of players in that virtual region, thereby lowering the response time of any interaction.},
	isbn = {978-1-60558-132-3},
	author = {Beskow, Paul and Vik, Knut-Helge and Halvorsen, P{\r a}l and Griwodz, Carsten},
	editor = {Claypool, Mark}
}
@inproceedings {Simula.ND.51,
	title = {Latency Reduction in Massively Multi-Player Online Games by Partial Migration of Game State},
	journal = {Second International Conference on Internet Technologies and Applications},
	year = {2007},
	month = {September},
	pages = {153-163},
	publisher = {Centre for Applied Internet Research (CAIR)},
	type = {Conference},
	address = {University of Wales, NEWI, Wrexham, UK.},
	abstract = {With the increasing popularity of massively multi-player online games (MMOGs), developers are continually forced to deal with the conflicting requirements of supporting a large number of concurrent users, while simultaneously providing low latency. As a result, a common way of distributing load is by dividing the virtual environment into logical regions. Geographically coupled users in such regions can be distinguished by analyzing IP addresses, RTTs or similar. This paper proposes the architecture for a decentralized middleware capable of utilizing such information, with the intent of decreasing the overall latency for the majority of users in that region. The latency reduction is accomplished by migrating a game region to a server closer in locality to the users, thereby lowering the response time of remote procedure calls. Due to the characteristics of MMOGs, the middleware implements a distributed name service, made possible by activating the system from a single node in the system.},
	isbn = {978-0-946881-54-3},
	author = {Beskow, Paul and Halvorsen, P{\r a}l and Griwodz, Carsten},
	editor = {Denise Oram Vic {Grout} and Picking, Rich}
}
