Abstract data types and high-level synthesis

If a program is structured using abstract data types as the basic unit of modularity, then that program is much easier to extend or modify. This thesis is illustrated by the staged development of a program to compute prime numbers based on the sieve of Eratosthenes. This paper includes an extensive introduction to the concept of abstract data types and can be used as a tutorial survey. It includes discussions on the use of abstract data types in connection with recent approaches to data abstractions, heirarchical structure, and program design. Abstract data types are an extension and modification of the traditional concept of data type. An abstract data type defines not only a data representation for objects of the type but also the set of operations that can be performed on objects of the type. Furthermore, the abstract data type can protect the data representation from direct access by other parts of the program.

Data Types (ADT) are used when creating software systems, in the systems design. Usually we use algebraic specification to specify the operations in a data type. The use of data types is a methodology or style of working which yields improved design when followed. In this paper we study the addition of input-output operations to the algebraic specification of operations over a data type. The motivation is that input-output operations are used in actual implementations. A specification with input-output is more complete than one without it. We need input-output operations in our programs. This justifies the addition of such operations to the specification. We consider the definition of input-output operations in functional programming in particular in Haskell. Our input-output specifications are not exactly equal to Haskell programs although some of them are likely. We specify input-output operations in a form likely to the specification of the other operations. The result is the algebraic specification of the input-output operations for many frequently used data types. The language considered is sufficiently expressive to model all these operations. The technique is illustrated by means of a variety of examples. We started from sequences, continued with sets and finish with dictionaries. The specifications we present in this paper can be used as specifications of methods of ADT definitions in object oriented programing.

This paper presents a novel approach to optimize the performance of a design synthesized from a given behavioral application. The high-level synthesis process is highly restricted by a pre-characterized library from which components are chosen to implement operations in the behavior. Moreover logic optimization on the register-transfer level datapath is typically limited to within the register boundaries that enclose the chosen components. It is imperative that the datapath components be carefully selected and synthesized in order to obtain a performance gain. The technique presented in this paper consists of two primary steps, application-specific macro generation and replacement, that are performed prior to high-level synthesis, The macro generation step extracts macro subgraphs from the given application graph and generates a macro component (an equivalent netlist)for each macro subgraph. Further; each macro component is optimized for performance using commercial logic synthesis tools. Using the enriched component library, a macro replacement step modifies the behavioral graph such that some subgraphs are replaced by equivalent macros. The replacement step attempts to replace subgraphs such that the design latency is minimized. The modified behavioral graph along with the enriched component library is then taken through high-level, logic and layout synthesis. Experiments on DSP benchmarks show that the macro based synthesis process achieves significant improvement in design performance as opposed to the traditional design process. We have developed an automated performance-optimization framework that is only limited by the optimization capability of backend tools.

One of the major enhancements that can be made to the high-level synthesis (HLS) process is reducing the overall area of a design in order to either decrease the manufacturing costs or to introduce more functionality to the circuit. Optimizing the area of the datapath is considered a primary field of research in HLS. This work proposes an approach to reduce the area in field programmable gate array (FPGA) by simultaneously tackling the three central tasks of HLS. Scheduling, allocation, and binding are performed and the optimal solution based on area reduction is obtained by using simulated annealing with a priority function. The aim of the priority function is to guide the simulated annealing process into finding the best solution while at the same time incurring the least possible execution time. In order to achieve better results than the initial solution, rescheduling, swapping operations between functional units, swapping variables between registers, and swapping inputs to functional units are considered in the annealing process. A cost function is devised to evaluate a potential move's success or failure. The simulation environment "Eridanus" has been developed in order to support implementation and testing. Several benchmarks were tested and the numerical results consisting of the execution time along with the best solution were recorded to illustrate the performance of the proposed technique. Area reduction was obtained compared to the conventional HLS flow; furthermore, an average substantial reduction in design space exploration time was obtained compared to non-priority based area optimization techniques.

This paper describes a study aimed at identifying different profiles of students' project development processes. Specifically, we assessed the use of abstract data types for the development of knowledge-based projects. The concept of abstract data types was introduced to high school students who took the course Computer Science-Logic Programming. During their studies the students learned and practiced various tools and methods of project development, one of which was based on the use of abstract data types as tools for problem solving and knowledge representation. To this end, a one-day workshop for team development of mini-projects was organized, and the whole development process was audio and video documented, categorized and analyzed. The pro- files of team behavior in the project development process were specified. The analysis of the profiles resulted in identifying four types of project development teams, all of which employed some or- ganizing tool in developing their projects. Two types of the developing teams used abstract data types and two used other methods. The findings indicated that the process of project development of those who used abstract data types was more structured and more organized than others.

In this article, we present a novel methodology based on SMT-solvers to verify equality of a high-level described specification and a pipelined RTL implementation produced by a high-level synthesis tool. The complex transformations existing in the high-level synthesis process, such as nested loop pipelining, cause the conventional methods of equivalence checking to be inefficient. The proposed equivalence checking method simultaneously attacks the two problems in this context: (1) state space explosion and (2) complex high-level synthesis transformations. To show the scalability and efficiency of the proposed method, the verification results of large designs are compared with those of the SAT-based method, including three different state-of-the-art SAT-solvers: the SMT-based procedure, the modular Horner expansion diagram (M-HED)-based method, and the M-HED partitioning approach. The results show 2470×, 2540×, and 142× average memory usage reduction and 252×, 28×, and 914× speedup in comparison with M-HED, M-HED partitioning, and SMT-solver without using the proposed method, respectively.

BackgroundRobust, extensible and distributed databases integrating clinical, imaging and molecular data represent a substantial challenge for modern neuroscience. It is even more difficult to provide extensible software environments able to effectively target the rapidly changing data requirements and structures of research experiments. There is an increasing request from the neuroscience community for software tools addressing technical challenges about: (i) supporting researchers in the medical field to carry out data analysis using integrated bioinformatics services and tools; (ii) handling multimodal/multiscale data and metadata, enabling the injection of several different data types according to structured schemas; (iii) providing high extensibility, in order to address different requirements deriving from a large variety of applications simply through a user runtime configuration.MethodsA dynamically extensible data structure supporting collaborative multidisciplinary research projects in neuroscience has been defined and implemented. We have considered extensibility issues from two different points of view. First, the improvement of data flexibility has been taken into account. This has been done through the development of a methodology for the dynamic creation and use of data types and related metadata, based on the definition of “meta” data model. This way, users are not constrainted to a set of predefined data and the model can be easily extensible and applicable to different contexts. Second, users have been enabled to easily customize and extend the experimental procedures in order to track each step of acquisition or analysis. This has been achieved through a process-event data structure, a multipurpose taxonomic schema composed by two generic main objects: events and processes. Then, a repository has been built based on such data model and structure, and deployed on distributed resources thanks to a Grid-based approach. Finally, data integration aspects have been addressed by providing the repository application with an efficient dynamic interface designed to enable the user to both easily query the data depending on defined datatypes and view all the data of every patient in an integrated and simple way.ResultsThe results of our work have been twofold. First, a dynamically extensible data model has been implemented and tested based on a “meta” data-model enabling users to define their own data types independently from the application context. This data model has allowed users to dynamically include additional data types without the need of rebuilding the underlying database. Then a complex process-event data structure has been built, based on this data model, describing patient-centered diagnostic processes and merging information from data and metadata. Second, a repository implementing such a data structure has been deployed on a distributed Data Grid in order to provide scalability both in terms of data input and data storage and to exploit distributed data and computational approaches in order to share resources more efficiently. Moreover, data managing has been made possible through a friendly web interface. The driving principle of not being forced to preconfigured data types has been satisfied. It is up to users to dynamically configure the data model for the given experiment or data acquisition program, thus making it potentially suitable for customized applications.ConclusionsBased on such repository, data managing has been made possible through a friendly web interface. The driving principle of not being forced to preconfigured data types has been satisfied. It is up to users to dynamically configure the data model for the given experiment or data acquisition program, thus making it potentially suitable for customized applications.

Structural semantics for polymorphic data types (preliminary report)

A signal-processing software system is described which allows the simulation of systems described by block diagrams or signal-flow graphs. A high-level data-flow language describes the interconnection of the components. All configurations of interconnections are allowed, including those containing feedback. Component systems (blocks) are allowed to be multi-input, multi-output, and to be programmed in any language. Blocks are implemented as separate processes running under a UNIX2 operating system. Input and output signals are transferred between blocks via the UNIXpipe facility. Thedata type of a signal is arbitrary in the context of the compiler; within a component or system, signals and internal variables can be either floating point or fixed point. The compiler enforces strong or weak type checking of signals according to the characteristics of the blocks generating and receiving the signals. The invariance of the program to implementation data type is accomplished by the use of abstract data types. Fixed-point simulations having differing number of bits per signal and per internal variable in a block are supported. Special display software is used to allow any signal in the system to be displayed on any graphics device.

Intellectual Property Protection (IPP) is one of the most important challenges for digital design development. Intellectural Properties (IP) and their reuse are usual today, but the use of IP design is raising design security issues. Watermarking is one of the efficient methods to detect an unauthorized use of an IP. A lot of interesting works have been proposed, but only a few of them combine watermarking process with the synthesis process. This article presents a new solution of watermarking embedded in a high level synthesis process.

The property called mutual exclusiveness, responsible for the degree of conditional reuse achievable after a high-level synthesis (HLS) process, is intrinsic to the systems behavior. However, sometimes it is only partially reflected in the actual description written by a designer. Our algorithm performs a transformation of the input description that exploits the maximum conditional reuse of the behavior, independently of description style, allowing the HLS tools to obtain circuits with less area.

The HLShield concept proposed in previous work aims at automating the augmentation of digital circuit designs with fault tolerance logic during the High-Level Synthesis (HLS) process. It proposes to use design analysis methods that identify parts of the design to protect against a certain fault hypothesis, a reliability-enhanced synthesis tool, and methods to validate the effectiveness of the added fault tolerance logic in order to automatically generate reliable digital designs using HLS. This work extends the HLShield framework by proposing a toolflow to estimate the influence of bit flips in user-defined sequential elements on the total failure rate a digital integrated circuit. It proposes a model that combines vendor-supplied reliability data with fault propagation probabilities for each class of sequential elements in the target device. Furthermore, this work presents an empirical method to determine these propagation probabilities using netlist-level fault injection techniques. We further apply these methods to analyze the failure rate improvement achievable using a method from previous work that aims at reducing a design's failure rate by selecting especially vulnerable sequential elements for protection. This is done according to register/memory access patterns in an intermediate representation of the high-level design. Results show choosing the correct metric has a noticeable influence on the achievable reduction in failure rate compared to the incurred overhead.

The UMIST Abstract Data Store is a software tool which supports abstract data types together with flexible mechanisms for specifying, for each abstract data type, alternative user interface and memory representations appropriate to different physical media. These mechanisms facilitate the definition of types, the specification of their alternative representations and the creation and manipulation of their values in a persistent fashion. The media supported may include such things as disks and visual displays and collections of these connected together via a network. This paper focuses on the mechanisms which have evolved in this environment for specifying safe user interfaces to complex data structures.

Specification directed testing is an important and largely unexplored area of software testing. We have built a prototype of a system to do specification directed testing of abstract data types. That system is called T-3. In building and using T-3 we have discovered some basic problems that must be addressed before such a system can be useful for most practical applications. This thesis describes those problems and our solutions to them. A correct software implementation can be viewed as one that (a) does everything it should; and (b) only does what it should. We show that specification directed testing should only be used to investigate (a). A new precise goal for specification directed testing based on this result is presented and developed. Previous methods for using PROLOG to produce test cases do not work for inequality predicates and cannot test all arbitrary sequences of function calls. A new method for using PROLOG to generate test cases that overcomes these limitations is presented. Previous methods for test set generation for specification directed software testing are based on the syntax of the axioms in the specifications of the software. We demonstrate the limitations of these methods by presenting simple faults that are never (even with infinite testing) detected by those previous methods. We have developed a new model of the computations of an abstract data type so that a new test set generation methodology could be developed. We have developed a new test set generation methodology that uses the semantics as well as the syntax of the software specification. It is based on: (1) our new computational model, (2) our method for using PROLOG to generate test cases, and (3) our new goal for specification directed software testing. We have validated this new methodology by comparing the number of faults it reveals to the number of faults revealed by previous methods.

Using a categorical model of abstract data types [2, 3, 13, 15], we show, following the Kozen's technique [10] and Tarjan's constructions for a deterministic automaton [16], that if two unambiguous regular expressions define the same regular language, then they represent two isomorphic abstract data types.