Vector-TASKING Timing Bundle

We work close­ly with our cus­tomers to cre­ate inno­v­a­tive solu­tions for the most com­plex develop­ment chal­lenges.

Vec­tor sup­ports, man­u­fac­tur­ers, and sup­pli­ers the auto­mo­tive indus­try and relat­ed indus­tries with a pro­fes­sion­al plat­form of tools, soft­ware com­po­nents and ser­vices for devel­op­ing embed­ded sys­tems. MICROSAR is Vec­tor’s embed­ded soft­ware for AUTOSAR ECUs. It con­sists of the run­time envi­ron­ment MICROSAR RTE and MICROSAR basic soft­ware mod­ules (BSW) includ­ing the oper­at­ing sys­tem (MICROSAR OS).

Vec­tor and TASKING col­lab­o­rate in cus­tomer and research projects to sup­port the inter­face between MICROSAR and winIDEA IDE.

Are you plan­ning to use our tools togeth­er with Vec­tor DaVin­ci Con­fig­u­ra­tor to ana­lyze the tim­ing behav­ior of your MICROSAR appli­ca­tion?

Are you inter­est­ed in thread states or Runnable tim­ing infor­ma­tion?

Get in touch with us and we will help you set it all up!

On this page

Vir­tu­al Func­tion Bus (VFB) Trac­ing
Vec­tor MICROSAR Tim­ing-Analy­sis
TASKING Inspec­tors
Webi­na­rs
Appli­ca­tion Notes

Vector-TASKING Timing Bundle

The new Vec­tor-TASK­ING Tim­ing Bun­dle con­tains a step by step guide­line to inte­grate sched­ul­ing trac­ing across the whole tool chain. From the con­fig­u­ra­tion of the MICROSAR.OS with­in the DaVin­ci Con­fig­u­ra­tor Pro via TASKING WinIDEA to the analy­sis of the result in Vec­tor’s TA Tool Suite. Addi­tion­al­ly, it deliv­ers the nec­es­sary scripts to autom­a­tize the entire process.

Video tuto­r­i­al (link on the right) shows how to get start­ed with OS pro­fil­ing using the Vec­tor-TASK­ING Tim­ing Bun­dle.

Down­load Free Bun­dle from Vec­tor web­site.

iSYSTEM and Vector Timing Bundle - How to Get Started
TASKING and Vec­tor Tim­ing Bun­dle — How to Get Start­ed

Vector MICROSAR OS Debug and Tracing

Vec­tor DaVin­ci Con­fig­u­ra­tor cre­ates an AUTOSAR ORTI file which tells the debug­ger how to get infor­ma­tion about OS objects such as Tasks, ISRs, and Alarms. The infor­ma­tion from the ORTI file can be used to dis­play OS infor­ma­tion while debug­ging, or to pro­vide dynam­ic infor­ma­tion via on-chip trace tech­niques. Addi­tion­al­ly, an TASKING pro­pri­etary XML file pro­vides sup­port for advanced trace use-cas­es such as thread state pro­fil­ing or VFB trac­ing.

OS objects debugging based on AUTOSAR ORTI File

A snap shot of the sta­tus of all OS objects described in the ORTI file can be dis­played via the OS Objects view. This view is acces­si­ble in winIDEA via the View, Oper­at­ing Sys­tems, Objects menu. For mul­ti-core appli­ca­tions a mul­ti-core ORTI file can be gen­er­at­ed in Vec­tor DaVin­ci Con­fig­u­ra­tor by selec­tion ORTI Debug Sup­port ORTI_23.

Sam­ple OS objects view

Task/ISR Profiling based on AUTOSAR ORTI File

Stan­dard ORTI Run­ning Task and Run­ning ISR2 trac­ing can be achieved by import­ing the ORTI file gen­er­at­ed by Vec­tor DaVin­ci Con­fig­u­ra­tor into winIDEA.

There is no need for code instru­men­ta­tion as all required run-time infor­ma­tion can be obtained by mon­i­tor­ing OS inter­nal data objects by means of on-chip hard­ware trace mech­a­nisms.

Example running Task and ISR2 Profiling
Exam­ple run­ning Task and ISR2 Pro­fil­ing

Thread State Profiling utilizing the Vector Timing-Hooks

In cer­tain use-cas­es, for exam­ple cal­cu­lat­ing the response time of a task, pro­fil­ing the run­ning task is not suf­fi­cient. For those use-cas­es a com­plete thread state trace of a MICROSAR appli­ca­tion can be record­ed. A thread state trace con­tains infor­ma­tion about pre­empt, resume, wait, and ter­mi­nate events in addi­tion to the run­ning thread infor­ma­tion. A thread state trace can be record­ed by uti­liz­ing the Vec­tor Tim­ing Hooks. These are ded­i­cat­ed hooks which can be used to sig­nal rel­e­vant thread state infor­ma­tion to the pro­fil­er.

TASKING pro­vides work­ing code for dif­fer­ent hard­ware archi­tec­tures and com­pil­ers that can be added to the appli­ca­tion. A ded­i­cat­ed TASKING Pro­fil­er XML file is used to inform the pro­fil­er about the sig­nal­ing. With this approach a com­plete thread state trace includ­ing the wait­ing (a task is wait­ing for an event or sem­a­phore) and new (a task has been acti­vat­ed but not start­ed yet) states can be record­ed as shown on the fol­low­ing screen­shot.

In addi­tion to the cur­rent­ly run­ning thread a thread state trace (see fig­ure on the right) also con­tains the infor­ma­tion about when a thread is acti­vat­ed, preempted/resumed, and ter­mi­nat­ed as indi­cat­ed by the NEW, READY/WAITING, and TERMINATED states.

Thread state trace

Vector MICROSAR RTE Virtual Function Bus (VFB) Tracing

A stan­dard fea­ture of the RTE is Vir­tu­al Func­tion­al Bus (VFB) trace. Indi­vid­ual Runnables can be select­ed by the user for VFB trace. The RTE gen­er­a­tor auto­mat­i­cal­ly gen­er­ates emp­ty Trace Hook func­tions, Runnable Start and Return Hook. These hook func­tions can be filled by suit­able trace instru­men­ta­tion code to sup­port Runnable pro­fil­ing by means of hard­ware data trace. TASKING can sup­port cus­tomers in imple­ment­ing those hooks in a con­ve­nient way.

OS thread and Runnable trace

Vector MICROSAR Timing-Analysis

Based on the pro­fil­ing data record­ed via hard­ware trac­ing the tim­ing behav­ior of a Vec­tor MICROSAR appli­ca­tion can be ana­lyzed. By default, the winIDEA Pro­fil­er pro­vides a stan­dard set of tim­ing met­rics. For advanced use-case TASKING Inspec­tors can be used to cov­er arbi­trary tim­ing-sce­nar­ios like AUTOSAR event-chains. Com­pat­i­bil­i­ty with the lead­ing tim­ing-analy­sis tool ven­dors is guar­an­teed by sup­port­ing the stan­dard­ized BTF trace for­mat.

Profiler Standard Metrics

The winIDEA pro­fil­er comes with a set of stan­dard tim­ing-met­rics to ana­lyze the run­time per­for­mance of a Vec­tor MICROSAR appli­ca­tion. Those met­rics are cal­cu­lat­ed for all pro­fil­er objects such as threads (tasks and ISRs), Runnables, and func­tions. The met­rics include net exe­cu­tion time, gross exe­cu­tion time, inac­ti­vate time, num­ber of occur­rences, and peri­od.

winIDEA Pro­fil­er

Timing-Extensions & Event-Chain Analysis using TASKING Inspectors

The TASKING Pro­fil­er fea­tures so-called Pro­fil­er Inspec­tors. These inspec­tors allow a user-defined post-analy­sis of the Pro­fil­er Time­line. They can be used for sophis­ti­cat­ed, user-spe­cif­ic event-chain analy­sis of trace record­ings, pre­sent­ed by the Pro­fil­er. An inspec­tor allows the cre­ation of a new pro­fil­er object, derived from the analy­sis of already exist­ing pro­fil­er objects.

As shown in the fig­ure, such inspec­tors can, for instance, be used to derive stan­dard AUTOSAR Tim­ing Met­rics (accord­ing to AUTOSAR_TR_TimingAnalysis). On the fig­ure you can see AUTOSAR Tim­ing Met­rics (orange) cal­cu­lat­ed by means of TASKING Inspec­tors based on the OS thread states (blue).

AUTOSAR Tim­ing Met­rics

BTF Export for Timing-Analysis in Third-Party Tools

Pro­fil­ing OS Task States and Runnable allows the TASKING Pro­fil­er to export the pro­fil­er time­line into the Best Trace For­mat (BTF). BTF is a stan­dard­ized trace for­mat used in the auto­mo­tive indus­try. This allows a seam­less import into var­i­ous Tim­ing Analy­sis tools (Vec­tor Infor­matik TA Inspec­tor, INCHRON chron­SIM, Lux­oft SymTA/S).

More resources

TypeLink Descrip­tion
Vec­tor MICROSAR Pro­fil­ingThis appli­ca­tion note describes how to use the TASKING winIDEA Ana­lyz­er for the tim­ing analy­sis of the Vec­tor MICROSAR oper­at­ing sys­tem.
Vec­tor-TASK­ING Tim­ing Bun­dleA step by step guide­line to inte­grate sched­ul­ing trac­ing across the whole tool chain. From the con­fig­u­ra­tion of the MICROSAR.OS with­in the DaVin­ci Con­fig­u­ra­tor Pro via TASKING winIDEA to the analy­sis of the result in Vec­tor’s TA Tool Suite.
Auto­mat­ic Tim­ing Sim­u­la­tion and Exe­cu­tion Time Mea­sure­ment with AUTOSARThis Vec­tor-TASK­ING Case Study describes how to auto­mate and com­bine tim­ing mod­el­ing with on-tar­get exe­cu­tion time mea­sure­ment to ensure the per­for­mance of real-time mul­ti-core sys­tems.
Non-Intru­sive AUTOSAR OS and RTE Pro­fil­ing of Vec­tor MICROSAR Appli­ca­tions This webi­nar aims at users who are devel­op­ing appli­ca­tions for micro­con­trollers that pro­vide full data and pro­gram flow trace capa­bil­i­ties via a ded­i­cat­ed trace inter­face.
 AUTOSAR OS and RTE Pro­fil­ing of Vec­tor MICROSAR Appli­ca­tions with Instru­men­ta­tionIn this webi­nar we will take a detailed look into OS and RTE pro­fil­ing of an MICROSAR OS based appli­ca­tion. Specif­i­cal­ly, we will uti­lize the Vec­tor OS tim­ing hooks to record task states and ISRs, as well as the VBF trace hooks to record Runnable events. The demo will be done on an Infi­neon TC399XE based appli­ca­tion, but the knowl­edge is applic­a­ble to the oth­er archi­tec­tures.
Scroll to Top