Chantana Chantrapornchai

Efficient scheduling for imprecise timing based on fuzzy theory

In this paper, we propose a framework for design exploration in architectural synthesis which takes imprecise timing information into account. Based on the fuzzy theory, we designed a polynomial-time scheduling algorithm called inclusive scheduling which can efficiently construct schedules close to the ones obtained by exhaustive search. A heuristic for evaluating an imprecise schedule latency with respect to a latency constraint with multiple acceptability degrees is also proposed. Experimental results shows the effectiveness and efficiency of our approach by comparing designs generated by our algorithm with the traditional scheduling scheme assuming worst case (or typical case) timing values, as well as exhaustive method.

Imprecise task schedule optimization

Considerable research has been done in order to schedule tasks on multiple processing systems. Some of the computation time of these tasks may, however, be imprecise due to the nature of the problem. In this paper, an imprecise task graph is used to model the problem where each node represents a task associated with its computation time. An algorithm, called rotation scheduling, is extended to handle the imprecise task scheduling and fuzzy arithmetic is used to estimate the size of a schedule. The goal of the algorithm is to give the optimized schedule as much as possible. Experiments showing the effectiveness of this approach are also presented.

Efficient algorithms for finding highly acceptable designs based on module-utility selections

In this paper we present an iterative framework to solve module selection problem under resource, latency, and power constraints. The framework associates a utility measure with each module. This measurement reflects the usefulness of the module for a given a design goal. Using modules with high utility values will result in superior designs. We propose a heuristic which iteratively perturbs module utility values until they tend to good module selections. Our experiments show that the module selections formed by combinations of modules with high utility values are superior solutions. Further by keeping modules with high utility values, the module exploration space can drastically be reduced.

Optimizing circuits with confidence probability using probabilistic retiming

VLSI circuit manufacturing results in theoretically identical components that actually have varying propagation delays. A worst-case or even average-case estimation of such delays during the design procedure may be overly pessimistic and will lead to costly and unnecessary redesign cycles. This paper presents a new optimization methodology, called probabilistic retiming, which transforms a circuit based on statistical timing data gathered either from component production histories or from a simulation of the fabrication process. Such circuits are modeled as graphs where each vertex represents a combinational element that has a probabilistic timing characteristic. A polynomial-time algorithm, applicable to such a graph, is developed which retimes a circuit in order to produce a design operating in a specified cycle time within a given confidence level. Experiments show that probabilistic retiming consistently produces faster circuits for a given confidence level, as compared with the traditional retiming algorithm.

Minimization of fuzzy systems based on fuzzy inference graphs

In a large fuzzy rule-based system, a great deal of computation time is required for a fuzzy inference engine. A given fuzzy rule-based system is modeled as a fuzzy inference graph where each node in the graph corresponds to a relation representing a rule in the rule-based system. This paper presents algorithms to minimize the number of nodes in the graph using fuzzy operations as well as their properties to reduce the computation time of each inference. The algorithm sorts a graph into stages, iteratively applies the two major operations, fuzzy union as well as composition and results in the new graph with the minimum number of nodes without increasing the dimensionality of each node.

Probabilistic Loop Scheduling Considering Communication Overhead

This paper presents a new methodology for statically scheduling a cyclic data-flow graph whose node computation times can be represented by random variables. A communication cost issue is also considered as another uncertain factor in which each node from the graph can produce different amount of data depending on the probability of its computation time. Since such communication costs rely on the amount of transfered data, this overhead becomes uncertain as well. We propose an algorithm to take advantage of the parallelism across a loop iteration while hiding the communication overhead. The resulting schedule will be evaluated in terms of confidence probability—the probability of having a schedule completed before a certain time. Experimental results show that the proposed framework performs better than a traditional algorithm running on an input which assumes fixed average timing information.

SHARP: efficient loop scheduling with data hazard reduction on multiple pipeline DSP systems

Computation intensive DSP applications usually require a parallel/pipelined processor in order to achieve specific timing requirements. Data hazards are a major obstacle against the high performance of pipelined systems. This paper presents a novel efficient loop scheduling algorithm that reduces data hazards for those DSP applications. Such an algorithm has been embedded in a tool, called SHARP, which schedules a pipelined data flow graph to multiple pipelined units, while hiding the underlying data hazards and minimizing the execution time. This paper reports significant improvement for some well-known benchmarks, showing the efficiency of the scheduling algorithm and the flexibility of the simulation tool.

Scheduling with confidence for probabilistic data-flow graphs

One of the biggest problems in high-level synthesis is to obtain a good schedule without the knowledge of exact computation time of tasks. While the target applications in high-level synthesis are becoming larger a task in the applications such as artificial intelligent systems or interface may have uncertain computation time. In this paper an algorithm to schedule these repetitive tasks and optimize the schedule is presented. A probabilistic data-flow graph is employed to model the problem where each node represents a task associated with the probabilistic computation time and a set of edges represents the dependences between the tasks. A novel polynomial-time probabilistic retiming algorithm for optimizing the graph and an algorithm for computing the optimized schedule, subject to the acceptable probability and resource constraint, are presented. The optimization algorithm also guarantees to give such a short schedule length with a given qualitatively provable, confidence level. The experiments show that the resulting schedule length for a given confidence probability can be significantly reduced.

Rapid prototyping for fuzzy systems

One of the common problems for fuzzy system implementation arises from the complications of the fuzzy inference process. Extra computations are required to deduce a consequence due to nature of fuzzy sets. Furthermore, considerable simulations need to be performed to verify system functions. In order to reduce the prototyping time, the fuzzy system is partitioned into hardware and software portions. The model, called Fuzzy Rule-based Automata (FRA), is proposed to simplify fuzzy rule base. Since most rule base are rarely changed, they can be implemented in hardware to speedup the running time. Special computations for inference process is taken care by software to reduce hardware complications which yields prototype flexibility.

Properties and Algorithms for Unfolding of Probabilistic Data-Flow Graphs

It is known that any selection statement (e.g. if and switch-case statements) in an application is associated with a probability which could either be predetermined by user input or chosen at runtime. Such a statement can be regarded as a computation node whose computation time is represented by a random variable. This paper focuses on iterative applications (containing loops) reflecting those uncertainties. Such an application can then be transformed to a probabilistic data-flow graph.Two timing models, the time-invariant and time-variant models, are introduced to characterize the nature of these applications. Since there can be many unfolding factors associated with each of the possible graph outcomes, for the time-invariant model, we propose a means of selecting a constant minimum rate-optimal unfolding factor for unfolding the probabilistic graph. We demonstrate that this factor guarantees the best schedule length.We also suggest a good estimate for choosing an unfolding factor for a graph under the time-variant model. Experiments show that using our selection scheme results in an iteration period close to the theoretical iteration bound of the experimental graph. Furthermore, this paper discusses an alternative approach which selects a few optimal schedules (with respect to the graph outcomes) to be stored in the system. The other possibilities will be represented by a modified template graph.