3,181 research outputs found
Test Generation Based on CLP
Functional ATPGs based on simulation are fast,
but generally, they are unable to cover corner cases, and
they cannot prove untestability. On the contrary, functional
ATPGs exploiting formal methods, being exhaustive,
cover corner cases, but they tend to suffer of the state
explosion problem when adopted for verifying large designs.
In this context, we have defined a functional ATPG
that relies on the joint use of pseudo-deterministic simulation
and Constraint Logic Programming (CLP), to
generate high-quality test sequences for solving complex
problems. Thus, the advantages of both simulation-based
and static-based verification techniques are preserved, while
their respective drawbacks are limited. In particular, CLP,
a form of constraint programming in which logic programming
is extended to include concepts from constraint satisfaction,
is well-suited to be jointly used with simulation. In
fact, information learned during design exploration by simulation
can be effectively exploited for guiding the search of
a CLP solver towards DUV areas not covered yet. The test
generation procedure relies on constraint logic programming
(CLP) techniques in different phases of the test generation
procedure.
The ATPG framework is composed of three functional
ATPG engines working on three different models of the
same DUV: the hardware description language (HDL)
model of the DUV, a set of concurrent EFSMs extracted
from the HDL description, and a set of logic constraints
modeling the EFSMs. The EFSM paradigm has been selected
since it allows a compact representation of the DUV
state space that limits the state explosion problem typical
of more traditional FSMs. The first engine is randombased,
the second is transition-oriented, while the last is
fault-oriented.
The test generation is guided by means of transition coverage and fault coverage. In particular, 100% transition
coverage is desired as a necessary condition for fault
detection, while the bit coverage functional fault model
is used to evaluate the effectiveness of the generated test
patterns by measuring the related fault coverage.
A random engine is first used to explore the DUV state
space by performing a simulation-based random walk. This
allows us to quickly fire easy-to-traverse (ETT) transitions
and, consequently, to quickly cover easy-to-detect (ETD)
faults. However, the majority of hard-to-traverse (HTT)
transitions remain, generally, uncovered.
Thus, a transition-oriented engine is applied to
cover the remaining HTT transitions by exploiting a
learning/backjumping-based strategy.
The ATPG works on a special kind of EFSM, called
SSEFSM, whose transitions present the most uniformly
distributed probability of being activated and can be effectively
integrated to CLP, since it allows the ATPG to invoke
the constraint solver when moving between EFSM states.
A constraint logic programming-based (CLP) strategy is
adopted to deterministically generate test vectors that satisfy
the guard of the EFSM transitions selected to be traversed. Given a transition of the SSEFSM, the solver
is required to generate opportune values for PIs that enable
the SSEFSM to move across such a transition.
Moreover, backjumping, also known as nonchronological
backtracking, is a special kind of backtracking
strategy which rollbacks from an unsuccessful
situation directly to the cause of the failure. Thus,
the transition-oriented engine deterministically backjumps
to the source of failure when a transition, whose guard
depends on previously set registers, cannot be traversed.
Next it modifies the EFSM configuration to satisfy the
condition on registers and successfully comes back to the
target state to activate the transition.
The transition-oriented engine generally allows us to
achieve 100% transition coverage. However, 100% transition
coverage does not guarantee to explore all DUV corner
cases, thus some hard-to-detect (HTD) faults can escape
detection preventing the achievement of 100% fault coverage.
Therefore, the CLP-based fault-oriented engine is finally
applied to focus on the remaining HTD faults.
The CLP solver is used to deterministically search for
sequences that propagate the HTD faults observed, but not
detected, by the random and the transition-oriented engine.
The fault-oriented engine needs a CLP-based representation
of the DUV, and some searching functions to generate
test sequences. The CLP-based representation is automatically
derived from the S2EFSM models according to the
defined rules, which follow the syntax of the ECLiPSe CLP
solver. This is not a trivial task, since modeling the
evolution in time of an EFSM by using logic constraints
is really different with respect to model the same behavior
by means of a traditional HW description language. At
first, the concept of time steps is introduced, required to
model the SSEFSM evolution through the time via CLP.
Then, this study deals with modeling of logical variables
and constraints to represent enabling functions and update
functions of the SSEFSM.
Formal tools that exhaustively search for a solution frequently
run out of resources when the state space to be analyzed
is too large. The same happens for the CLP solver,
when it is asked to find a propagation sequence on large sequential
designs. Therefore we have defined a set of strategies
that allow to prune the search space and to manage the
complexity problem for the solver
Recommended from our members
User-led Innovation in the UK National Health Service
Healthcare services are delivered to patients using complex technology systems. Many innovative healthcare technologies are produced by industrial suppliers; however, healthcare staff are also active innovators of the technologies that they use in their own work. By assuming the role of user-innovators, they can create new technologies, procedures, processes and service-designs that improve and support healthcare provision. The focus of the research reported in this thesis is the phenomenon of user-led innovation of healthcare technology in the UK National Health Service (NHS).
Exploratory research was carried out to develop a detailed understanding of user-led innovation within the NHS based on the perspectives of user-innovators. This thesis presents the results of the research in the form of four interpretive case studies, that contribute to an understanding of the enabling and inhibiting factors affecting user-led innovation. Each case presents an overview of the process of user-led innovation which was followed and the context in which it occurred. Several distinctive characteristics of user-led innovation are identified and a generic activity model of the user-led innovation process is described. Evaluation in user-led innovation processes is highlighted to have multiple purposes,beyond objective technology assessment. It is shown to support the on-going social-construction of user-developed technologies but also highlights the role of evaluation as a resource for exercising political influence within the innovation process.
User led innovation is established as a theoretically useful and coherently defined mode of innovation, distinct from the lead user or open innovation paradigms. The major contribution of the thesis is an integrated model of healthcare technology systems that emphasises the role of protoinstitutions as critical products of user-led innovation. The thesis concludes that in order to maximise the benefit of user-led innovation in the NHS, innovation policy and practice should be
broadened to recognise the role of proto-institutions as a valuable product of user-led innovation
An interactive semantics of logic programming
We apply to logic programming some recently emerging ideas from the field of
reduction-based communicating systems, with the aim of giving evidence of the
hidden interactions and the coordination mechanisms that rule the operational
machinery of such a programming paradigm. The semantic framework we have chosen
for presenting our results is tile logic, which has the advantage of allowing a
uniform treatment of goals and observations and of applying abstract
categorical tools for proving the results. As main contributions, we mention
the finitary presentation of abstract unification, and a concurrent and
coordinated abstract semantics consistent with the most common semantics of
logic programming. Moreover, the compositionality of the tile semantics is
guaranteed by standard results, as it reduces to check that the tile systems
associated to logic programs enjoy the tile decomposition property. An
extension of the approach for handling constraint systems is also discussed.Comment: 42 pages, 24 figure, 3 tables, to appear in the CUP journal of Theory
and Practice of Logic Programmin
Disruption management
The main objective of this project is to model the ARP (Aircraft Recovery Problem) from a constraint programming (CP) point of view. The information required for this project is extracted from previous papers that cope with the problem using heuristics, metaheuristics or using network-models. Also, two scenarios will be tested to verify that the implementation is correct
Recommended from our members
Working notes of the 1991 spring symposium on constraint-based reasoning
A New Method for Fuzzy Critical Path Analysis in Project Networks with a New Representation of Triangular Fuzzy Numbers
The method for finding fuzzy optimal solution of fully fuzzy critical path (FFCP) problems i.e., critical path problems in which all the parameters are represented by fuzzy numbers, is at best scant; possibly non-existent. In this paper, a method is proposed to find the fuzzy optimal solution of FFCP problems, together with a new representation of triangular fuzzy numbers. This paper will show the advantages of using, the proposed representation over the existing representations of triangular fuzzy numbers and will present with great clarity the proposed method and illustrate its application to FFCP problems occurring in real life situations
Penerapan Algoritma Genetika untuk Sistem Penjadawalan Kuliah
Timetables problems arise because of some work done simultaneously, while its resources are limited, a scheduling problem can occur in scheduling sporting events, programs converensi, scheduling in educational institutions, the scheduling of railways, as well as the scheduling of the colleges that have complexity a very big problem that arises because the number of students, faculty and lecture meetings that should be done at the same time very much but constrained in the limited space and time. This resulted in a clash in the classroom, faculty, and students. Completion of this problem requires techniques and computational methods for optimum results. This study proposes a method for the genetic algorithm timetable system at the university. a case study conducted at the faculty of computer science, University of Al Asyariah Mandar. System testing has been done by combining hard and soft constraint constraint resulted in scheduling courses are created automatically and solutions that do not conflict with the schedule of preparation time schedule relatively faster. Scheduling information system can developet with web-based applications and other optimization methods
Local consistency for extended CSPs
AbstractWe extend the framework of Constraint Satisfaction Problems to make it more suitable for/applicable to modern constraint programming languages where both constraint satisfaction and constraint solving have a role. Some rough principles for local consistency conditions in the extended framework are developed, appropriate notions of local consistency are formulated, and relationships between the various consistency conditions are established
Analysis of nonlinear constraints in CLP(R)
Solving nonlinear constraints over real numbers is a complex problem. Hence constraint logic programming languages like CLP(R) or Prolog III solve only linear constraints and delay nonlinear constraints until they become linear. This efficient implementation method has the disadvantage that sometimes computed answers are unsatisfiable or infinite loops occur due to the unsatisfiability of delayed nonlinear constraints. These problems could be solved by using a more powerful constraint solver which can deal with nonlinear constraints like in RISC-CLP(Real). Since such powerful constraint solvers are not very efficient, we propose a compromise between these two extremes. We characterize a class of CLP(R) programs for which all delayed nonlinear constraints become linear at run time. Programs belonging to this class can be safely executed with the efficient CLP(R) method while the remaining programs need a more powerful constraint solver
- …