Change search
Refine search result
1 - 18 of 18
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Rows per page
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sort
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
Select
The maximal number of hits you can export is 250. When you want to export more records please use the Create feeds function.
  • 1.
    Drabent, Wlodek
    et al.
    University of Linköping.
    Maluszynski, Jan
    University of Linköping.
    Pietrzak, Pawel
    Locating type errors in untyped CLP programs2000In: Analysis and Visualization Tools for Constraint Programming: Constraint Debugging, Berlin: Encyclopedia of Global Archaeology/Springer Verlag, 2000, p. 121-150Chapter in book (Other academic)
    Abstract [en]

    This chapter presents a static diagnosis tool that locates type errors in untyped CLP programs without executing them. The existing prototype is specialised for the programming language CHIP [4.10], but the idea applies to any CLP language. The tool works with approximated specifications which describe types of procedure calls and successes. The specifications are expressed as a certain kind of term grammars. The tool automatically locates at compile time all the errors (with respect to a given specification) in a program. The located erroneous program fragments are (prefixes of) clauses. The tool aids the user in constructing specifications incrementally; often a fragment of the specification is already sufficient to locate an error. The presentation is informal. The focus is on the motivation of this work and on the functionality of the tool. Some related formal aspects are discussed in [4.15, 4.29]. The prototype tool is available from http://www.ida.liu.se/~pawpi/Diagnoser/diagnoser.html.

    Download full text (pdf)
    FULLTEXT01
  • 2.
    Drabent, Wlodek
    et al.
    University of Linköping.
    Maluszynski, Jan
    University of Linköping.
    Pietrzak, Pawel
    Parametric descriptive types for CLP2001In: Programmation en logique avec contraintes: actes des JFPLC'2001 [10e Journées francophones de programmation logique et programmation par contraintes], 24 avril-27 avril 2001, Cité des sciences et de l'industrie, Paris / [ed] Philippe Codognet, Paris: Hermés Science Publications , 2001, p. 239-256Conference paper (Refereed)
  • 3.
    Drabent, Wlodek
    et al.
    University of Linköping.
    Maluszynski, Jan
    University of Linköping.
    Pietrzak, Pawel
    Type-based diagnosis of CLP programs2000In: WLPE'99: Tenth Workshop on Logic Programming Environments, in connection with ICLP'99, International Conference on Logic Programming, Las Cruces, New Mexico, USA, 29 November 1999, Amsterdam: Elsevier, 2000Conference paper (Refereed)
    Abstract [en]

    The paper presents a diagnosis tool for CLP programs. It deals with partial correctness w.r.t. specifications which describe procedure calls and successes. The space of possible specifications is restricted to a kind of regular types; we propose a generalization of the concept of types used in so called descriptive typing of logic programs. In particular we distinguish ground types from those containing non-ground elements.The tool is able to automatically locate at compile time all errors in a program, this means all the clauses or clause prefixes responsible for the program being incorrect w.r.t. a given specification. The tool aids the user in constructing specifications incrementally; often a fragment of the specification is already sufficient to locate an error.Our prototype is specialized for the programming language CHIP, but the idea is applicable to any untyped CLP (and LP) language. We believe that the presented approach makes it possible to combine the advantages of typed and untyped programming languages.

  • 4.
    Drabent, Wlodek
    et al.
    Linköping University.
    Maluszynski, Jan
    Linköping University.
    Pietrzak, Pawel
    Using parametric set constraints for locating errors in CLP programs2002In: Theory and Practice of Logic Programming, ISSN 1471-0684, E-ISSN 1475-3081, Vol. 2, no 4-5, p. 549-611Article in journal (Refereed)
    Abstract [en]

    This paper introduces a framework of parametric descriptive directional types for Constraint Logic Programming (CLP). It proposes a method for locating type errors in CLP programs, and presents a prototype debugging tool. The main technique used is checking correctness of programs w.r.t. type specifications. The approach is based on a generalization of known methods for proving the correctness of logic programs to the case of parametric specifications. Set constraint techniques are used for formulating and checking verification conditions for (parametric) polymorphic type specifications. The specifications are expressed in a parametric extension of the formalism of term grammars. The soundness of the method is proved, and the prototype debugging tool supporting the proposed approach is illustrated on examples. The paper is a substantial extension of the previous work by the same authors concerning monomorphic directional types.

    Download full text (pdf)
    FULLTEXT01
  • 5.
    Drabent, Wlodek
    et al.
    University of Linköping.
    Pietrzak, Pawel
    Type analysis for CHIP1999In: Algebraic Methodology and Software Technology: 7th International Conference, AMAST'98 Amazonia, Brazil, January 4-8, 1999 Proceedings / [ed] Armando Martin Haeberer, Encyclopedia of Global Archaeology/Springer Verlag, 1999, p. 389-405Conference paper (Refereed)
    Abstract [en]

    This paper proposes a tool to support reasoning about (partial) correctness of constraint logic programs. The tool infers a specification that approximates the semantics of a given program. The semantics of interest is an operational "call-success" semantics. The main intended application is program debugging. We consider a restricted class of specifications, which are regular types of constrained atoms. Our type inference approach is based on bottom-up abstract interpretation, which is used to approximate the declarative semantics (c-semantics). By using "magic transformations" we can describe the call-success semantics of a program by the declarative semantics of another program. We are focused on CLP over finite domains. Our prototype program analyzer works for the programming language CHIP.

    Download full text (pdf)
    FULLTEXT01
  • 6.
    Eliasson, Jens
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Delsing, Jerker
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Lindgren, Per
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Pietrzak, Pawel
    Kyusakov, Rumen
    Project: Architecture for Service-Oriented Process – Monitoring and Control2011Other (Other (popular science, discussion, etc.))
  • 7.
    Eriksson, Johan
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Aittamaa, Simon
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Wiklander, Jimmie
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Pietrzak, Pawel
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Lindgren, Per
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    SRP-DM scheduling of component-based embedded real-time software2011Conference paper (Refereed)
    Abstract [en]

    Model and component based design is an established means for the development of large software systems, and is starting to get momentum in the realm of embedded software development. In case of safety critical (dependable systems) it is crucial that the underlying model and its realization captures the requirements on the timely behavior of the system, and that these requirements can be preserved and validated throughout the design process (from specification to actual code execution). To this end, we base the presented work on the notion of Concurrent Reactive Objects (CRO) and their abstraction into Reactive Components.In many cases, the execution platform puts firm resource limitations on available memory and speed of computations that must be taken into consideration for the validation of the system.In this paper, we focus on code synthesis from the model, and we show how specified timing requirements are preserved and translated into scheduling information. In particular, we present how ceiling levels for Stack Resources Policy (SRP) scheduling and analysis can be extracted from the model. Additionally, to support schedulability analysis, we detail algorithms that for a CRO model derives periods (minimum inter-arrival times) and offsets of tasks/jobs. Moreover, the design of a micro-kernel supporting cooperative hardware- and software-scheduling of CRO based systems under Deadline Monotonic SRP is presented.

    Download full text (pdf)
    FULLTEXT01
  • 8.
    Kero, Martin
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Pietrzak, Pawel
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Nordlander, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Computer Science.
    Live heap space bounds for real-time systems2010In: Programming languages and systems: 8th Asian symposium, APLAS 2010, Shanghai, China, November28 - December 1 2010 : proceedings, Berlin: Encyclopedia of Global Archaeology/Springer Verlag, 2010, p. 287-303Conference paper (Refereed)
    Abstract [en]

    Live heap space analyses have so far been concerned with the standard sequential programming model. However, that model is not very well suited for embedded real-time systems, where fragments of code execute concurrently and in orders determined by periodic and sporadic events. Schedulability analysis has shown that the programming model of real-time systems is not fundamentally in conflict with static predictability, but in contrast to accumulative properties like time, live heap space usage exhibits a very state-dependent behavior that renders direct application of schedulability analysis techniques unsuitable.

    In this paper we propose an analysis of live heap space upper bounds for real-time systems based on an accurate prediction of task execution orders. The key component of our analysis is the construction of a non-deterministic finite state machine capturing all task executions that are legal under given timing assumptions. By adding heap usage information inferred for each sequential task, our analysis finds an upper bound on the inter-task heap demands as the solution to an integer linear programming problem. Values so obtained are suitable inputs to other analyses depending on the size of a system’s persistent state, such as running time prediction for a concurrent tracing garbage collector.

    Download full text (pdf)
    fulltext
  • 9.
    Lindgren, Per
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Eriksson, Johan
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Aittamaa, Simon
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Pietrzak, Pawel
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Wiklander, Jimmie
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Scheduling of CRO systems under SPR-DM2011Conference paper (Refereed)
  • 10.
    Lindgren, Per
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Kyusakov, Rumen
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Eliasson, Jens
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Mäkitaavola, Henrik
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Pietrzak, Pawel
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    A SOA approach to delay and jitter tolerant distributed real-time complex event processing2013In: 2013 IEEE International Symposium on Industrial Electronics (ISIE 2013): Taipei, Taiwan, 28 - 31 May 2013; [proceedings], Piscataway, NJ: IEEE Communications Society, 2013Conference paper (Refereed)
    Abstract [en]

    The combination of Service Oriented Architectures (SOAs) and Complex Event Processing (CEP) is gaining momen- tum for event centric management and processing of informa- tion in complex distributed systems (e.g., business automation). Whereas systems for factory automation have traditionally been deployed using dedicated buses and proprietary (often scan based) protocols, a recent trend in process automation is towards adopting open internet based technologies and event based communication. This trend is driven by the increasing number and capabilities of devices used for monitoring and control, and the increased flexibility, maintainability and price/performance gains expected from IP (potentially SOA/CEP) enabled systems.In this paper we discuss the challenges involved to apply SOA and CEP to the field of factory automation. In particular, real- time aspects are highlighted, both w.r.t. to accurate time-stamping of physical events in a distributed system, as well as end-to-end timing including communication and CEP processing.We approach the challenges by an architecture combining state-of-the-art synchronisation mechanisms for wired and wire- less networks together with real-time communication and dis- tributed query processing based on the notion of time constrained reactions. We discuss the impact of synchronisation inaccuracies and delays introduced by processing and communication, and present a method for implementation of safe potential- and certain matches.

    Download full text (pdf)
    fulltext
  • 11.
    Lindgren, Per
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Pietrzak, Pawel
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Mäkitaavola, Henrik
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Real-time complex event processing using concurrent reactive objects2013In: Proceedings of the IEEE International Conference on Industrial Technology: ICIT 2013, Cape Town, South Africa 25 February 2013 - 28 February 2013, Piscataway, NJ: IEEE Communications Society, 2013, p. 1994-1999Conference paper (Refereed)
    Abstract [en]

    Service Oriented Architectures (SOAs) and Complex Event Processing (CEP) are established technologies in the area of business automation. In combination, SOA and CEP allow for event centric management and processing of information in complex distributed systems. Whereas systems for process monitoring and control traditionally have been deployed using dedicated buses and proprietary (often scan-based) protocols, a recent trend in process automation is towards adopting open Internet-based technologies. This trend is driven by the increasing number and capabilities of devices used for monitoring and control

  • 12. Pietrzak, Pawel
    A type-based framework for locating errors in constraint logic programs2002Doctoral thesis, comprehensive summary (Other academic)
    Download full text (pdf)
    FULLTEXT01
  • 13. Pietrzak, Pawel
    Static incorrectness diagnosis of CLP(FD)1998Licentiate thesis, comprehensive summary (Other academic)
    Download full text (pdf)
    FULLTEXT01
  • 14. Pietrzak, Pawel
    et al.
    Correas, Jesus
    Complutense University, Madrid.
    Puebla, German
    Technical University of Madrid.
    Hermenegildo, Manuel
    Technical University of Madrid.
    A practical type analysis for verification of modular Prolog programs2008In: Proceedings of the 2008 ACM SIGPLAN symposium on Partial evaluation and semantics-based program manipulation, ACM Digital Library, 2008, p. 61-70Conference paper (Refereed)
    Abstract [en]

    Regular types are a powerful tool for computing very precise descriptive types for logic programs. However, in the context of reallife, modular Prolog programs, the accurate results obtained by regular types often come at the price of efficiency. In this paper we propose a combination of techniques aimed at improving analysis efficiency in this context. As a first technique we allow optionally reducing the accuracy of inferred types by using only the types defined by the user or present in the libraries. We claim that, for the purpose of verifying type signatures given in the form of assertions the precision obtained using this approach is sufficient, and show that analysis times can be reduced significantly. Our second technique is aimed at dealing with situations where we would like to limit the amount of reanalysis performed, especially for library modules. Borrowing some ideas from polymorphic type systems, we show how to solve the problem by admitting parameters in type specifications. This allows us to compose new call patterns with some precomputed analysis info without losing any information. We argue that together these two techniques contribute to the practical and scalable analysis and verification of types in Prolog programs.

    Download full text (pdf)
    FULLTEXT01
  • 15. Pietrzak, Pawel
    et al.
    Correas, Jesus
    Complutense University, Madrid.
    Puebla, German
    Technical University of Madrid.
    Hermenegildo, Manuel
    Technical University of Madrid.
    Context-sensitive multivariant assertion checking in modular programs2006In: Logic for Programming, Artificial Intelligence, and Reasoning: 13th International Conference, LPAR 2006, Phnom Penh, Cambodia, November 13-17, 2006. Proceedings / [ed] Miki Hermann; Andrei Voronkov, Berlin: Encyclopedia of Global Archaeology/Springer Verlag, 2006, p. 392-406Conference paper (Refereed)
    Abstract [en]

    We propose a modular, assertion-based system for verification and debugging of large logic programs, together with several interesting models for checking assertions statically in modular programs, each with different characteristics and representing different trade-offs. Our proposal is a modular and multivariant extension of our previously proposed abstract assertion checking model and we also report on its implementation in the CiaoPP system. In our approach, the specification of the program, given by a set of assertions, may be partial, instead of the complete specification required by traditional verification systems. Also, the system can deal with properties which cannot always be determined at compile-time. As a result, the proposed system needs to work with safe approximations: all assertions proved correct are guaranteed to be valid and all errors actual errors. The use of modular, context-sensitive static analyzers also allows us to introduce a new distinction between assertions checked in a particular context or checked in general.

    Download full text (pdf)
    fulltext
  • 16. Pietrzak, Pawel
    et al.
    Hermenegildo, Manuel
    Technical University of Madrid.
    Automatic binding-related error diagnosis in logic programs2007In: Logic Programming: 23rd International Conference, ICLP 2007, Porto, Portugal, September 8-13, 2007. Proceedings / [ed] Verónica Dahl; Ilkka Neimelä, Berlin: Encyclopedia of Global Archaeology/Springer Verlag, 2007, p. 333-347Conference paper (Refereed)
    Abstract [en]

    This paper proposes a diagnosis algorithm for locating a certain kind of errors in logic programs: variable binding errors that result in abstract symptoms during compile-time checking of assertions based on abstract interpretation. The diagnoser analyzes the graph generated by the abstract interpreter, which is a provably safe approximation of the program semantics. The proposed algorithm traverses this graph to find the point where the actual error originates (a reason of the symptom), leading to the point the error has been reported (the symptom). The procedure is fully automatic, not requiring any interaction with the user. A prototype diagnoser has been implemented and preliminary results are encouraging.

    Download full text (pdf)
    FULLTEXT01
  • 17.
    Pietrzak, Pawel
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Kyusakov, Rumen
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Eliasson, Jens
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Lindgren, Per
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Roadmap for SOA event processing and service execution in real-time using Timber2011In: 2011 IEEE International Symposium on Industrial Electronics (ISIE 2011): Gdansk, Poland, 27 - 30 June 2011, Piscataway, NJ: IEEE Communications Society, 2011, p. 1727-1732Conference paper (Refereed)
    Abstract [en]

    The introduction of Service Oriented Architectures for monitoring and control involves the deployment of SOA onto lightweight devices (e.g., embedded controllers for sensors and actuators). For the use of SOA in applications where timing and dependability are important, it becomes crucial that SOA event processing and service implementations are robust and time bound for a given platform. To this end, formalisms and tools aiding the design is instrumental. In this paper, we present a roadmap for a SOA based on components using the modeling and programming paradigm of Timber. Our vision is to present Timber based software components as services. By using current standards for service descriptions and eventing we will facilitate interoperability with legacy systems. We will develop a compiler tool suit allowing Timber based services to be deployable onto lightweight resource constrained platforms (e.g., sensors and actuators for industrial use). Our goal is to provide design time guarantees on e.g., robustness (safety and liveness), timing properties, and resource utilization for the complete embedded system comprising SOA event communication, event processing together with the service implementations.

  • 18.
    Pietrzak, Pawel
    et al.
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Lindgren, Per
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Mäkitaavola, Henrik
    Luleå University of Technology, Department of Computer Science, Electrical and Space Engineering, Embedded Internet Systems Lab.
    Towards a lightweight CEP engine for embedded systems2012In: IECON 2012: 38th Annual Conference of the IEEE Industrial Electronics Society, Piscataway, NJ: IEEE Communications Society, 2012, p. 5805-5810Conference paper (Refereed)
    Abstract [en]

    Industrial process automation systems are adopting event based communication. Pushing control loops towards low- level devices implies a need for lightweight embedded devices that are able to recognize and to react to events. Atomic events however, such as a value read by an individual sensor exceeding certain value, do not separately suffice to capture scenarios where a reaction should occur to a sequence of low-level events matching certain pattern, rather than to a single atomic event. Therefore, it becomes desirable that resource-constrained low- level devices are equipped with some, possibly lightweight, form of event filtering and processing. In this paper we propose to implement a lightweight complex event processing using the concurrent reactive objects (CRO) model. A core feature of the CRO model is its s ability to react to atomic events. Between the reactions, which basically are function executions, the system remains idle, and thus does not occupy the CPU and is energy-efficient. Additionally, CRO models can be executed in an efficient and predictable manner onto resource constrained platforms and offers low-overhead real-time scheduling through exploiting underlying interrupt hardware according to given time constraints.

1 - 18 of 18
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf