Kista infrastructure for SystemC simulation and Time Analysis The recursive name is a pun in honour to the Kista campus of KTH, where it has been developped. Moreover, "kista" swedish word means "last" in English! Last update: 2014/04/20: Binary release R336
Sources	Description	Date	Version.
Kista V1.0	First version pending for release	to come
current sources	So far, this sources are only available for a KTH.SE authenticated user	available
Binary Distributions	Binary distribution of the KisTA library and KisTA-XML front-end tool, plus examples
kista_R336_ubuntu_12.04L_64b.tar.gz	Several fixes in the functions which control functional validation. Now, it is possible to disable functional validation from the XML front-end and execute normally the KisTA executable without having to remove the calls which control the instatiation and configuration of the functional validator in the user source code. These functions will be simply ignored in such a case.	2014/04/20	R336

Access to older binary distributions of KisTA can be found here.

User Guidelines

Description:

KisTA is a SystemC-based library for enabling simulation and time analysis of concurrent applications on multiprocessor-based systems. KisTA has also an XML front-end, called KisTA-XML
KisTA focuses on the time assessment of the time-critical parts of a system. For it, KisTA enables the modelling of predictable systems, supporting formally-based application models, and predictable platforms models, which include different scheduling policies and scheduler models, and predictable hardware architectures. KisTA is being built as an independent tool, provided by KTH and which can be grown by the research community.

KisTA adopts in its way ideas developed by other simulation tools such as SCoPE tool, e.g. suitability conection with exploration tools, and actually adds hook to exploit SCoPE automatic annotation tools.
SCoPE is oriented to the extimation of complex embedded architectures, with caches, shared buses and memory, which let reach better resource utilization and thus efficiency in the implementation solution,
but which are complex to analyze and assess. It also focuses on fast simulation speed, to make affordable design-space exploration.

In its focus to predictable systems KisTA adds complementary concepts, such as:
- providing a variety of predefined scheduling policies, specially focusing on SW layers suitable for predictable systems,
- supporting an application modelling close to system-level models based on Model of Computation theory,
- supporting a generic modelling of communication resources which enable to build on top of it specific models of communication infrastructures, and where the characterization of the predictability of the communication resource is a main feature,
- supporting gradual modelling, so a user can check with precision the abiding to simple analytical models, and check the impact on performance of further details in the model.
- based on discrete-event simulation fully integrated in a SystemC environment, thus focusing more on accuracy than on simulation speed, for the purposes of time assessment of predictable systems.
- additional features, such as detection of periodic phases (in an stationary state) to enable metrics report related to such stationary state.

The complementariety of KisTA and SCoPE concepts can lead to an improved simulation framework in the context of present and/or future research (e.g. CONTREX project), supporting performance assesment for mixed-critical systems (MCS).
Efficient MCS architectures will need to integrate predictable parts and parts oriented to average performance optimization. Therefore, a simulation framework has to be ready to efficiently cope with the
simulation and estimation of the performance of such heterogeneous architectures.

Current Modelling Capabilities:

Distinction between System and Environment. The environment can be a pure SystemC model, connected to a System model supporting the following features
at Application level:
  tasks and task sets; macros for task modelling; hooks to actual functionality or workloads (worst case execution time or WCET, and worst case instruction time WCEI); synchronization and communication elements (memoryless and registered event, semaphores, blocking fifo buffers).
at platform level:
  - Software platform elements:  local schedulers, which a variety of predefined task scheduling policies (static and dynamic,priority based, EDF, etc), with the possibility to support static communication schedulings;
  - Hardware platform elements: generic processing elements (configuration of frequency and cycles per instruction (CPI), with or without network interface; generic communication resources, and predefined communication resources (currently, a tdma bus),
and architectural mappings (allocation of task sets to local schedulers, of schedulers to processing elements, allocations of communication resources), and connections at hardware level.

Outputs:
Simulation considering to the allocation to resources; utilizations of processing elements, of schedulers and of tasks; response times, throughputs; traces of task state and utilization signals; detection of violation of time constraints; static analysis (utilizations, densities); assesments of starvation or locks.

Front-End/Back-End capabilities:
KisTA can be used:

• through a C++ API, as a C++ library relying on SystemC.
• as a black-box through a XML interface (supporting modelling capabilities from the XML interface have to be consulted here).

The XML interface is compatible with the Multicube format, which facilitates the use of this framework for DSE, supported by tools like Multicube Explorer, MOST and Esteco.

Other features:
KisTA supports the integration of automatic workload annotations through a hook to the SCoPE annotation tool (scope-g++ with the switch opcost for annotation)
KisTA integrates a wide set of checks to warn or notify the user of model errors or inconsistencies.
KisTA supports the automatic export of an editable .ticks sketch of the captured model, which can be in turn automatically exported to a .pdf format.
KisTA integrate features for automatically determining a sufficient execution time to show a given number of hyperperiods in the simulation trace. Of course, this depends on the fact that the hyperperiods can be calculated and make sense in the model.
KisTA library includes a set of examples to sistematically show the different features.

Roadmap:
A lot of nice features are seen as feasible extensions by the authors. KisTA should link easily to SystemC-based system-level specification frameworks, such as ForSyDe-SystemC, found in the ForSyDe site, or to  HetSC, and to model-based modelling methodologies. For them, KisTA can be used as a back-end capable to provide performance assessment. The performance modelling capabilities can be alos improved, through the support of global schedulers; and by providing  features for the integration with other simulation frameworks (e.g., SCoPE or the Nostrum network simulator),  First bunch of material (user guide, tutorial, etc is to come).

Contact: fernanhc@kth.se