Peter Kourzanov - Academia.edu (original) (raw)
Papers by Peter Kourzanov
The main goal of dynamic memory allocators is to minimize memory fragmentation. Fragmentation ste... more The main goal of dynamic memory allocators is to minimize memory fragmentation. Fragmentation stems from the interaction between workload behavior and allocator policy. There are, however, no works systematically capturing said interaction. We view this gap as responsible for the absence of a standardized, quantitative fragmentation metric, the lack of workload dynamic memory behavior characterization techniques, and the absence of a standardized benchmark suite targeting dynamic memory allocation. Such shortcomings are profoundly asymmetric to the operation's ubiquity. This paper presents a trace-based simulation methodology for constructing representations of workload-allocator interaction. We use two-dimensional rectangular bin packing (2DBP) as our foundation. 2DBP algorithms minimize their products' makespan, but virtual memory systems employing demand paging deem such a criterion inappropriate. We see an allocator's placement decisions as a solution to a 2DBP instance, optimizing some unknown criterion particular to that allocator's policy. Our end product is a data structure
ABSTRACT This paper presents our approach to Cyber-physical System (CPS) simulation including a n... more ABSTRACT This paper presents our approach to Cyber-physical System (CPS) simulation including a number of embedded nodes that form a wireless network. On one hand, we use the NS-2 discrete-event simulator as a C++ kernel for running network simulation scenarios, while on the other hand, a combination of components written using standard Scheme as well as a number of Domain-Specific Language (DSL) instances embedded into Scheme (implementing pattern-matching, logic-relational models, and Web programming) are used in a cloud-based tool-set that supports research exploration cycle where variation in network parameters is compared to the resulting CPS performance. These components cooperate to provide an intuitive Web-based user interface, analysis tools and a seamless work-flow including visualization.
Lecture Notes in Computer Science, 2013
ABSTRACT Scheme is a minimalist language that brings its ancestor, LISP, on par with modern langu... more ABSTRACT Scheme is a minimalist language that brings its ancestor, LISP, on par with modern languages such as *ML and Haskell. Although it has very different tools in its repertoire (e.g., homoiconicity), many of the same techniques applied in other languages are also quite usable in Scheme. Some of them (e.g., pattern-matching, monadic and multi-stage programming, a notation for laziness) tend to be associated with other languages (primarily: Haskell and OCaml), and hence many programmers liking these constructs are drawn away from Scheme. The concrete reason for this in FP community is the perceived verbosity of Scheme, while others (in particular, from the embedded community) have troubles adopting the more difficult concepts of FP in general. It is clear that there are approaches developed with FP that do help for productivity in hardware and software design. Transfer of this knowledge, however, is made difficult by an intellectual gap between the communities. In this paper we attempt to reconcile these two points of view by showing that (1) Scheme’s minimalistic but flexible approach can bring concrete benefits to the embedded community, and (2) none of these “advanced” features is particularly hard to replicate in a language such as Scheme. If one is willing to leverage Scheme’s hygienic macros, all of these features can be implemented separately as libraries and freely used together. No advanced compiler or interpreter modifications to implement such extensions are required for creating embedded DSLs in it. To really see what Scheme (and homoiconicity) can bring to the domain of automated program construction, and to apply these ideas in practice to Software-Defined Radio (SDR) stacks, we have re-implemented a multi-staged, monadic FFT generator. In this paper we supplement it with a straightforward implementation of the C code-generation and Graphviz visualization back-ends and argue for a homoiconic, pure and total language to combine the best features of Scheme, Haskell and *ML.
An architecture for interactive, notebook-based ns-3 simulations in the cloud is proposed. A prot... more An architecture for interactive, notebook-based ns-3 simulations in the cloud is proposed. A prototype implementation of an example study for IEEE 802.11p inter-channel interference is developed as a test-case, using direct integration of ns-3 components with Jupyter via Julia's C++ support. This shows that flexible animations with advanced visualization of live ns-3 simulation results can be setup quickly. Although the system appears complex, the benefits of ns-3 as fast and flexible discrete event simulator complement Julia's scalability in numerical computing and Jupyter's versatility on the Web and provide supporting evidence of LiveSim as a promising direction for multi-modal, reproducible network research.
Electronic proceedings in theoretical computer science, Jun 30, 2022
I would like to tell a story. A story about a beautiful mathematical relationship that elucidates... more I would like to tell a story. A story about a beautiful mathematical relationship that elucidates the computational view on the classic subject of trigonometry. All stories need a language, and for this particular story an algorithmic language ought to do well. What makes a language algorithmic? From our perspective as the functional programming community, an algorithmic language provides means to express computation in terms of functions, with no implementation-imposed limitations. We develop a new algorithm for the computation of trigonometric functions on dyadic rationals, together with the language used to express it, in Scheme. We provide a mechanically-derived algorithm for the computation of the inverses of our target functions. We address efficiency and accuracy concerns that pertain to the implementation of the proposed algorithm either in hardware or software.
ABSTRACT This paper describes the design and the implementation of a framework for multimedia inf... more ABSTRACT This paper describes the design and the implementation of a framework for multimedia information management. The framework is built upon two notions. One is a model that describes multimedia information management by (1) defining foundation objects that defines different aspects of multimedia management and by providing a composition that brings those different aspects together in a consistent way and provides interoperability between them. The other is a distributed infrastructure, that is, CORBA, in which the model has been implemented. In this paper we give an overview of the COMMOTION model and its implementation. In the description of the implementation we focus on the implementation of a server and a client component. Our emphasis at the server side is the integration and implementation of standardized CORBA services as well as additional multimedia functionality. At the client side we emphasize the integration of existing frameworks/submodels into COMMOTION. Finally, we describe the main components we have built using the implementation
arXiv (Cornell University), May 24, 2024
Architectural simulators hold a vital role in RISC-V research, providing a crucial platform for w... more Architectural simulators hold a vital role in RISC-V research, providing a crucial platform for workload evaluation without the need for costly physical prototypes. They serve as a dynamic environment for exploring innovative architectural concepts, enabling swift iteration and thorough analysis of performance metrics. As deep learning algorithms become increasingly pervasive, it is essential to benchmark new architectures with machine learning workloads. The diverse computational kernels used in deep learning algorithms highlight the necessity for a comprehensive compilation toolchain to map to target hardware platforms. This study evaluates the performance of a wide array of machine learning workloads on RISC-V architectures using gem5, an open-source architectural simulator. Leveraging an open-source compilation toolchain based on Multi-Level Intermediate Representation (MLIR), the research presents benchmarking results specifically focused on deep learning inference workloads. Additionally, the study sheds light on current limitations of gem5 when simulating RISC-V architectures, offering insights for future development and refinement.
Electronic Proceedings in Theoretical Computer Science
I would like to tell a story. A story about a beautiful mathematical relationship that elucidates... more I would like to tell a story. A story about a beautiful mathematical relationship that elucidates the computational view on the classic subject of trigonometry. All stories need a language, and for this particular story an algorithmic language ought to do well. What makes a language algorithmic? From our perspective as the functional programming community, an algorithmic language provides means to express computation in terms of functions, with no implementation-imposed limitations. We develop a new algorithm for the computation of trigonometric functions on dyadic rationals, together with the language used to express it, in Scheme. We provide a mechanically-derived algorithm for the computation of the inverses of our target functions. We address efficiency and accuracy concerns that pertain to the implementation of the proposed algorithm either in hardware or software.
Proceedings of the 10th Workshop on ns-3 - WNS3 '18, 2018
Proceedings of the 1st Industry Track on Software Language Engineering, 2016
We introduce PURE, a pure declarative approach to implementing declarative transformations with d... more We introduce PURE, a pure declarative approach to implementing declarative transformations with declarative tools. This DomainSpecific Language (DSL), inspired by the Definite Clause Grammar (DCG) and Parsing Expression Grammar (PEG) formalisms, is implemented using the Revised Report on the Algorithmic Language Scheme (R5RS). Thanks to its use of the MINIKANREN logic programming system it supports fully reversible and extensible syntax-semantics relations. In this paper we highlight the usability and simplicity of PURE’s approach, address the problem of leftrecursion and show how its features help in defining custom and extensible typing systems for JavaScript Object Notation (JSON).
Rapid pace of innovation in industrial research labs requires fast algorithm evaluation cycles. T... more Rapid pace of innovation in industrial research labs requires fast algorithm evaluation cycles. The use of multi-core hardware and distributed clusters is essential to achieve reasonable turnaround times for high-load simulations. Julia’s support for these as well as its pervasive multiple dispatch make it very attractive for high-performance technical computing. Our experiments in speeding up a Digital Signal Processing (DSP) Intellectual Property (IP) model simulation for a Wireless LAN (WLAN) product confirm this. We augment standard SystemC High-Level Synthesis (HLS) tool-flow by an interactive worksheet supporting performance visualization and rapid design space exploration cycles.
Lecture Notes in Computer Science, 2013
ABSTRACT Scheme is a minimalist language that brings its ancestor, LISP, on par with modern langu... more ABSTRACT Scheme is a minimalist language that brings its ancestor, LISP, on par with modern languages such as *ML and Haskell. Although it has very different tools in its repertoire (e.g., homoiconicity), many of the same techniques applied in other languages are also quite usable in Scheme. Some of them (e.g., pattern-matching, monadic and multi-stage programming, a notation for laziness) tend to be associated with other languages (primarily: Haskell and OCaml), and hence many programmers liking these constructs are drawn away from Scheme. The concrete reason for this in FP community is the perceived verbosity of Scheme, while others (in particular, from the embedded community) have troubles adopting the more difficult concepts of FP in general. It is clear that there are approaches developed with FP that do help for productivity in hardware and software design. Transfer of this knowledge, however, is made difficult by an intellectual gap between the communities. In this paper we attempt to reconcile these two points of view by showing that (1) Scheme’s minimalistic but flexible approach can bring concrete benefits to the embedded community, and (2) none of these “advanced” features is particularly hard to replicate in a language such as Scheme. If one is willing to leverage Scheme’s hygienic macros, all of these features can be implemented separately as libraries and freely used together. No advanced compiler or interpreter modifications to implement such extensions are required for creating embedded DSLs in it. To really see what Scheme (and homoiconicity) can bring to the domain of automated program construction, and to apply these ideas in practice to Software-Defined Radio (SDR) stacks, we have re-implemented a multi-staged, monadic FFT generator. In this paper we supplement it with a straightforward implementation of the C code-generation and Graphviz visualization back-ends and argue for a homoiconic, pure and total language to combine the best features of Scheme, Haskell and *ML.
Proceedings of International Workshop on Engineering Simulations for Cyber-Physical Systems - ES4CPS '14, 2007
The main goal of dynamic memory allocators is to minimize memory fragmentation. Fragmentation ste... more The main goal of dynamic memory allocators is to minimize memory fragmentation. Fragmentation stems from the interaction between workload behavior and allocator policy. There are, however, no works systematically capturing said interaction. We view this gap as responsible for the absence of a standardized, quantitative fragmentation metric, the lack of workload dynamic memory behavior characterization techniques, and the absence of a standardized benchmark suite targeting dynamic memory allocation. Such shortcomings are profoundly asymmetric to the operation's ubiquity. This paper presents a trace-based simulation methodology for constructing representations of workload-allocator interaction. We use two-dimensional rectangular bin packing (2DBP) as our foundation. 2DBP algorithms minimize their products' makespan, but virtual memory systems employing demand paging deem such a criterion inappropriate. We see an allocator's placement decisions as a solution to a 2DBP instance, optimizing some unknown criterion particular to that allocator's policy. Our end product is a data structure
ABSTRACT This paper presents our approach to Cyber-physical System (CPS) simulation including a n... more ABSTRACT This paper presents our approach to Cyber-physical System (CPS) simulation including a number of embedded nodes that form a wireless network. On one hand, we use the NS-2 discrete-event simulator as a C++ kernel for running network simulation scenarios, while on the other hand, a combination of components written using standard Scheme as well as a number of Domain-Specific Language (DSL) instances embedded into Scheme (implementing pattern-matching, logic-relational models, and Web programming) are used in a cloud-based tool-set that supports research exploration cycle where variation in network parameters is compared to the resulting CPS performance. These components cooperate to provide an intuitive Web-based user interface, analysis tools and a seamless work-flow including visualization.
Lecture Notes in Computer Science, 2013
ABSTRACT Scheme is a minimalist language that brings its ancestor, LISP, on par with modern langu... more ABSTRACT Scheme is a minimalist language that brings its ancestor, LISP, on par with modern languages such as *ML and Haskell. Although it has very different tools in its repertoire (e.g., homoiconicity), many of the same techniques applied in other languages are also quite usable in Scheme. Some of them (e.g., pattern-matching, monadic and multi-stage programming, a notation for laziness) tend to be associated with other languages (primarily: Haskell and OCaml), and hence many programmers liking these constructs are drawn away from Scheme. The concrete reason for this in FP community is the perceived verbosity of Scheme, while others (in particular, from the embedded community) have troubles adopting the more difficult concepts of FP in general. It is clear that there are approaches developed with FP that do help for productivity in hardware and software design. Transfer of this knowledge, however, is made difficult by an intellectual gap between the communities. In this paper we attempt to reconcile these two points of view by showing that (1) Scheme’s minimalistic but flexible approach can bring concrete benefits to the embedded community, and (2) none of these “advanced” features is particularly hard to replicate in a language such as Scheme. If one is willing to leverage Scheme’s hygienic macros, all of these features can be implemented separately as libraries and freely used together. No advanced compiler or interpreter modifications to implement such extensions are required for creating embedded DSLs in it. To really see what Scheme (and homoiconicity) can bring to the domain of automated program construction, and to apply these ideas in practice to Software-Defined Radio (SDR) stacks, we have re-implemented a multi-staged, monadic FFT generator. In this paper we supplement it with a straightforward implementation of the C code-generation and Graphviz visualization back-ends and argue for a homoiconic, pure and total language to combine the best features of Scheme, Haskell and *ML.
An architecture for interactive, notebook-based ns-3 simulations in the cloud is proposed. A prot... more An architecture for interactive, notebook-based ns-3 simulations in the cloud is proposed. A prototype implementation of an example study for IEEE 802.11p inter-channel interference is developed as a test-case, using direct integration of ns-3 components with Jupyter via Julia's C++ support. This shows that flexible animations with advanced visualization of live ns-3 simulation results can be setup quickly. Although the system appears complex, the benefits of ns-3 as fast and flexible discrete event simulator complement Julia's scalability in numerical computing and Jupyter's versatility on the Web and provide supporting evidence of LiveSim as a promising direction for multi-modal, reproducible network research.
Electronic proceedings in theoretical computer science, Jun 30, 2022
I would like to tell a story. A story about a beautiful mathematical relationship that elucidates... more I would like to tell a story. A story about a beautiful mathematical relationship that elucidates the computational view on the classic subject of trigonometry. All stories need a language, and for this particular story an algorithmic language ought to do well. What makes a language algorithmic? From our perspective as the functional programming community, an algorithmic language provides means to express computation in terms of functions, with no implementation-imposed limitations. We develop a new algorithm for the computation of trigonometric functions on dyadic rationals, together with the language used to express it, in Scheme. We provide a mechanically-derived algorithm for the computation of the inverses of our target functions. We address efficiency and accuracy concerns that pertain to the implementation of the proposed algorithm either in hardware or software.
ABSTRACT This paper describes the design and the implementation of a framework for multimedia inf... more ABSTRACT This paper describes the design and the implementation of a framework for multimedia information management. The framework is built upon two notions. One is a model that describes multimedia information management by (1) defining foundation objects that defines different aspects of multimedia management and by providing a composition that brings those different aspects together in a consistent way and provides interoperability between them. The other is a distributed infrastructure, that is, CORBA, in which the model has been implemented. In this paper we give an overview of the COMMOTION model and its implementation. In the description of the implementation we focus on the implementation of a server and a client component. Our emphasis at the server side is the integration and implementation of standardized CORBA services as well as additional multimedia functionality. At the client side we emphasize the integration of existing frameworks/submodels into COMMOTION. Finally, we describe the main components we have built using the implementation
arXiv (Cornell University), May 24, 2024
Architectural simulators hold a vital role in RISC-V research, providing a crucial platform for w... more Architectural simulators hold a vital role in RISC-V research, providing a crucial platform for workload evaluation without the need for costly physical prototypes. They serve as a dynamic environment for exploring innovative architectural concepts, enabling swift iteration and thorough analysis of performance metrics. As deep learning algorithms become increasingly pervasive, it is essential to benchmark new architectures with machine learning workloads. The diverse computational kernels used in deep learning algorithms highlight the necessity for a comprehensive compilation toolchain to map to target hardware platforms. This study evaluates the performance of a wide array of machine learning workloads on RISC-V architectures using gem5, an open-source architectural simulator. Leveraging an open-source compilation toolchain based on Multi-Level Intermediate Representation (MLIR), the research presents benchmarking results specifically focused on deep learning inference workloads. Additionally, the study sheds light on current limitations of gem5 when simulating RISC-V architectures, offering insights for future development and refinement.
Electronic Proceedings in Theoretical Computer Science
I would like to tell a story. A story about a beautiful mathematical relationship that elucidates... more I would like to tell a story. A story about a beautiful mathematical relationship that elucidates the computational view on the classic subject of trigonometry. All stories need a language, and for this particular story an algorithmic language ought to do well. What makes a language algorithmic? From our perspective as the functional programming community, an algorithmic language provides means to express computation in terms of functions, with no implementation-imposed limitations. We develop a new algorithm for the computation of trigonometric functions on dyadic rationals, together with the language used to express it, in Scheme. We provide a mechanically-derived algorithm for the computation of the inverses of our target functions. We address efficiency and accuracy concerns that pertain to the implementation of the proposed algorithm either in hardware or software.
Proceedings of the 10th Workshop on ns-3 - WNS3 '18, 2018
Proceedings of the 1st Industry Track on Software Language Engineering, 2016
We introduce PURE, a pure declarative approach to implementing declarative transformations with d... more We introduce PURE, a pure declarative approach to implementing declarative transformations with declarative tools. This DomainSpecific Language (DSL), inspired by the Definite Clause Grammar (DCG) and Parsing Expression Grammar (PEG) formalisms, is implemented using the Revised Report on the Algorithmic Language Scheme (R5RS). Thanks to its use of the MINIKANREN logic programming system it supports fully reversible and extensible syntax-semantics relations. In this paper we highlight the usability and simplicity of PURE’s approach, address the problem of leftrecursion and show how its features help in defining custom and extensible typing systems for JavaScript Object Notation (JSON).
Rapid pace of innovation in industrial research labs requires fast algorithm evaluation cycles. T... more Rapid pace of innovation in industrial research labs requires fast algorithm evaluation cycles. The use of multi-core hardware and distributed clusters is essential to achieve reasonable turnaround times for high-load simulations. Julia’s support for these as well as its pervasive multiple dispatch make it very attractive for high-performance technical computing. Our experiments in speeding up a Digital Signal Processing (DSP) Intellectual Property (IP) model simulation for a Wireless LAN (WLAN) product confirm this. We augment standard SystemC High-Level Synthesis (HLS) tool-flow by an interactive worksheet supporting performance visualization and rapid design space exploration cycles.
Lecture Notes in Computer Science, 2013
ABSTRACT Scheme is a minimalist language that brings its ancestor, LISP, on par with modern langu... more ABSTRACT Scheme is a minimalist language that brings its ancestor, LISP, on par with modern languages such as *ML and Haskell. Although it has very different tools in its repertoire (e.g., homoiconicity), many of the same techniques applied in other languages are also quite usable in Scheme. Some of them (e.g., pattern-matching, monadic and multi-stage programming, a notation for laziness) tend to be associated with other languages (primarily: Haskell and OCaml), and hence many programmers liking these constructs are drawn away from Scheme. The concrete reason for this in FP community is the perceived verbosity of Scheme, while others (in particular, from the embedded community) have troubles adopting the more difficult concepts of FP in general. It is clear that there are approaches developed with FP that do help for productivity in hardware and software design. Transfer of this knowledge, however, is made difficult by an intellectual gap between the communities. In this paper we attempt to reconcile these two points of view by showing that (1) Scheme’s minimalistic but flexible approach can bring concrete benefits to the embedded community, and (2) none of these “advanced” features is particularly hard to replicate in a language such as Scheme. If one is willing to leverage Scheme’s hygienic macros, all of these features can be implemented separately as libraries and freely used together. No advanced compiler or interpreter modifications to implement such extensions are required for creating embedded DSLs in it. To really see what Scheme (and homoiconicity) can bring to the domain of automated program construction, and to apply these ideas in practice to Software-Defined Radio (SDR) stacks, we have re-implemented a multi-staged, monadic FFT generator. In this paper we supplement it with a straightforward implementation of the C code-generation and Graphviz visualization back-ends and argue for a homoiconic, pure and total language to combine the best features of Scheme, Haskell and *ML.
Proceedings of International Workshop on Engineering Simulations for Cyber-Physical Systems - ES4CPS '14, 2007