Gift-VT Tools Development Overview

GIFT-VT Tools Overview

Agenda

Tools Levels.

The gift file.

Execute Tool by the Server.

Tools MakeFile.

The Tools layer

We have several types of Tools:

Generic.

LineShmoo, ExecuteAllPats etc.

Product specific.

ScanOut, LCP etc.

Platform Specific

S9KPutCompare

Produc & Platform Specific

DTN_S9KRaster

Tools layer

For each type we have:

Service classes

Common task which used by Tools and Modules (i.e. CoutputServer or CfailureTable)

Module classes

Implements a specific algorithm within a Tool, this algorithm may be used by several Tools (i.e. CShmoo or CStability )

Tool classes

Implements a specific Tool algorithm (i.e. CColumnShmoo or CLCP_DC ).

Classes – Tools, Modules & Services CBaseTool Modules Tools Services inheritance CBaseTool C2DShmoo CShmoo CStability CLineShmoo CLCP_DC CRunShmoo CScanOut CFailureTable COutputServer CAddressCalc CConfigServer

Gift file

Every tool need a gift file:

The gift file include the tool name

# UF: ToolName

All Tool Params (Globlas)

A line starting with “ # ” is a comment.

A line starting with “: ;” is an empty line.

A line like “:XXX;” is a header line (the XXX will be green in the GUI).

All other lines are parameter lines, each divided into fields by the “;” delimiter:

First field is a name and must begin with the “-“ character (for clift).

Second field is the parameter name to be passed to the Tool.

Third field is the parameter type (INT, FLOAT, STRING).

Fourth field is the parameter short description to appear in the GUI and in the Tool header.

Gift file cont’

Fourth field parameter

If the field ends with “#0” the field is read only – user can change it only if it has a drop-down menu.

If the field ends with “#5!” the field appears as a button. The five subsequent lines will correspond to a sub window that will pop up when clicking the button.

Fifth field is the parameter help line that appears in the GUI when the mouse points at the parameter.

Sixth field is optional. When it exists the field becomes a menu field.

The tokens in the field (separated by coma “,”) are the menu contents.

If the content of the field is “<2#>” the menu content will come from the configuration file.

Seventh field is also optional. The value(s) of each token replaces the corresponding item selected in the sixth field menu for transmission to the Tool.

Gift file Example.

# GIFT/CLIFT Configuration file for Example

# UF: Example

# -------------------------------------------

# This is a comment.

:This is the header;

-First; DBG_First_Param; int; First Parameter#0; Help line 1; One,Two; 1,2;

# Empty line

: ;

-Second; DBG_Second_Param; string; Second Parameter; Help line 2; One,Two,Three;

:This is another header;

-Third; DBG_Third_Param; int; Third Parameter; Help line 3;

-Options; DBG_Options; string; Options#2!; More options; Yes,No; 1,2;

:Options header;

-FirstOption; DBG_First_Options; int; First Option;

-SecondOption; DBG_Second_Options; int; Second Option;

#end of gift file

Execute Tool

In order to execute a tool the server translate a string tool name to the func pointer.

Get Tool Name form the .gift file

E.g. MyTool

Loading the tool from the disk to mem.

P = dlopen(“ MyTool ”);

Get ‘MyTool’ exec & Check functions

Pcheck = dlsym(p,” MyTool _Check”);

Prun = dlsym(p,” MyTool _Run”)

Note:

The name of Run/Check functions has to be the same as Tool MyTool file name.

MakeFile

# This is a Makefile for the VT project

# General flags

GIFTVT_ROOT = /afs/iil.intel.com/tmn/eng/tcg/TMN_TCG_11/GiftVT

TARGET = $(GIFTVT_ROOT)/VT_lib/tools_lib/generic_tools_lib/

LIBNAME = libExample

GIFTNAME = Example.gift

CFLAGS = -fPIC -fexceptions -g -c –o

INCLUDE = -I$(GIFTVT_ROOT)/src/include

-I$(GIFTVT_ROOT)/src/GiftVT_Utiles

-I$(GIFTVT_ROOT)/src/generic_tools/ToolFuncs

LIBS = -L$(GIFTVT_ROOT)/VT_lib/emul_funcs_lib/ - lVTfuncs

-L$(GIFTVT_ROOT)/VT_lib/tools_lib/generic_tools_lib/ - lToolFuncs

SRCS = CExample.cpp

OBJS = ${SRCS:.cpp=.o}

Makefile cont’

build_objects:

make_lib_share: ${OBJS}

@echo "Building Shared Library " ${TARGET}/${LIBNAME}.so.${M1}.${M2} " ..."

${LD} -shared -G -z text -o ${TARGET}/${LIBNAME}.so.${M1}.${M2} ${OBJS} ${LIBS}

@echo "Done."

@echo ""

make_link:

@echo "Make a link to " ${TARGET}/${LIBNAME}.so.${M1}.${M2} " ..."

@ rm -f ${TARGET}/${LIBNAME}.so

ln -s ${LIBNAME}.so.${M1}.${M2} ${TARGET}/${LIBNAME}.so

@echo "Done."

@echo ""

add_gift:

@echo "Add Gift file" ${GIFTNAME} "to " ${TARGET}/${LIBNAME}.so.${M1}.${M2} " ..."

@echo "" >> ${TARGET}/${LIBNAME}.so.${M1}.${M2}

@cat ${GIFTNAME} >> ${TARGET}/${LIBNAME}.so.${M1}.${M2}

@echo "Done."

@echo ""

System Architecture GIFT-VT Typical GUI

S9K IX Tester IMS Vanguard Tester S9K KX Tester

Features:

Select the component to work on

Select the tester to use

All User interface is GUI based

Same Tool used over Platform

Same platform for many componets

GIFT-VT Debug Tool suite, Over Platform

System used in:

Odem CD (IMS & KX)

Banias CD (IMS & IX)

DV (KX)

Banias (IX)

SC

Structural Tester (ST2) tester support (VT) is being developed in SC

Gift1.0 disadvantages

Define only for S9K.

User have to know basic ASAP.

All tools linked together (take them all).

In case of problem in one tool you can’t compile/run ASAP.

Gift files not part of the tool.

New tool.

Change other tools and compile them too.

Add tool to TP.

Add some blocks to your TP (globals pat_list etc.).

(done in gift1.25).

Compile again your TP.

VTtools base

VTtools

readme.1.0.txt

src

include

bns_tools

ims_funcs

s9k_funcs

VT_lib

bns_tools_lib

ims_funcs_lib

s9k_funcs_lib

src

tools

Makefile

Tools C functions (-> Tools_liblibtools.so )

ims_funcs

Makefile

ims C++ functions (-> Funcs_libims_liblibfuncs.so )

s9k_funcs

Makefile

.c9k UF ( -> .op )

s9k C functions (-> Funcs_libs9k_liblibfuncs.so )

lib

Tools_lib

libserver.so.

libLineShmoo.so.

etc.

Funcs_lib

all_lib

libfuncs.so

ims_lib

libfuncs.so

s9k_lib

libfuncs.so

include

.h files

Con’t VT imp

Run Tool

gift send ToolParameters, ToolName to server().

Server :

SetToolParams.

Load lib tool .so and call tool.

Tool :

GetToolParams.

Load & Run VTfuncs.

PutCompare

//////////////////////////////////////////////////////////////////////////////

// CTMN_S9KPutCompare . cpp

// $GIFT - VT;Tool;timna$

//

// Contains : definitions for class CTMN_S9KPutCompare

//

// 23/06/2001 Cohen Alon Creation

// Revision History : None

/*

* $Header : / afs / iil . intel . com / tmn / eng / tcg / TMN_TCG_4 / GIFT_FILES / Tools / Active / Aux / RCS / TMN_S9KPutCompare . cpp,v 1.0 2001-06-14 23:03:13+03 cecp Exp $

* $RCSfile : TMN_S9KPutCompare . cpp,v $

* $Revision : 1.0 $

* $Date : 2001-06-14 23:03:13+03 $

* $Id : TMN_S9KPutCompare . cpp,v 1.0 2001-06-14 23:03:13+03 cecp Exp $

* $Log : TMN_S9KPutCompare . cpp,v $

* Revision 1.0 2001-06-14 23:03:13+03 cecp

* Initial revision

*

*

*

*/

// CTMN_S9KPutCompare

//////////////////////////////////////////////////////////////////////////////

#include <stdio . h>

#include <stdlib . h>

#include <iostream . h>

#include <vtFunctions . h>

#include <CTimer . h>

#include <CGlobalsHandle . h>

#define S9K_TOOL_NAME " TMN_S9KPutCompare "

#define RUN_S9K_TOOlS_DBG 1

typedef int (* func1 )( char * buffer, FILE * fic ) ;

typedef int (* func2 )( void ) ;

static char * rcsid = " $Id : TMN_S9KPutCompare . cpp,v 1.0 2001-06-14 23:03:13+03 cecp Exp $ " ;

static char * rcsrev = " $Revision : 1.0 $ " ;

extern " C " {

extern int check_PutCompare ( char * buffer, FILE * fic ) ;

extern int PutCompare ( void ) ;

VTBoolean TMN_S9KPutCompare_Check ( ParamsContainer & Container, char * zResponseBuf ) ;

VTBoolean TMN_S9KPutCompare_Run ( ParamsContainer & Container, char * zResponseBuf ) ;

}

static func1 pFuncCheck = check_PutCompare;

static func2 pFuncExec = PutCompare;

//--------------------------------------------------------------------

// TMN_S9KPutCompare_Check

//--------------------------------------------------------------------

VTBoolean TMN_S9KPutCompare_Check ( ParamsContainer & Container, char * zResponseBuf )

{

VTBoolean bOk = VT_TRUE;

VTBoolean obRet = VT_TRUE;

// CGlobalsHandle MyGlobalsHandle ( Container ) ;

// if ( RUN_S9K_TOOlS_DBG )

// MyGlobalsHandle . mOutObj . PrintDebug ( VT_TRUE ) ;

if (! zResponseBuf ) {

// ERROR

// MyGlobalsHandle . mOutObj . Print ( ERROR, " zResponseBuf is NULL ") ;

return VT_FALSE;

}

sprintf ( zResponseBuf, "% s; " ,zResponseBuf ) ;

// bOk = MyGlobalsHandle . SetAllToolsParams () ;

///////////////////////////////////////////////////////////////////////////////////////

string sName = " UFG_comp_field " ;

ParamsContainer :: iterator Iter = Container . find ( sName ) ;

if ( Iter == Container . end ()) {

printf ("% s - Paremeter name not found " ,sName . c_str ()) ;

}

else{

vtSetToolParam (( char *)(* Iter ). second . msName . c_str () ,SVAL, ( char *)(* Iter ). second . msValue . c_str ()) ;

}

sName = " UFG_comp_field1 " ;

Iter = Container . find ( sName ) ;

}

else{

}

sName = " UFG_comp_field2 " ;

Iter = Container . find ( sName ) ;

}

else{

}

///////////////////////////////////////////////////////////////////////////////////////

// MyGlobalsHandle . mOutObj . Print ( DEBUG, " Check Tool % s " ,S9K_TOOL_NAME ) ;

// Execute CheckS9ktool

printf ("**** run pFuncCheck *** ") ;

obRet = ( VTBoolean ) pFuncCheck ( zResponseBuf,NULL ) ;

// MyGlobalsHandle . mOutObj . Print ( DEBUG, " Check return % d, zResponseBuf = % s " ,obRet,zResponseBuf ) ;

printf ("**** End of run pFuncCheck *** ") ;

return obRet;

}

//--------------------------------------------------------------------

// TMN_S9KPutCompare_Run

//--------------------------------------------------------------------

VTBoolean TMN_S9KPutCompare_Run ( ParamsContainer & Container, char * zResponseBuf )

{

VTBoolean bOk = VT_TRUE;

VTBoolean obRet = VT_TRUE;

CTimer Timer;

CGlobalsHandle MyGlobalsHandle ( Container ) ;

if ( RUN_S9K_TOOlS_DBG )

MyGlobalsHandle . mOutObj . PrintDebug ( VT_TRUE ) ;

MyGlobalsHandle . mOutObj . Print ( DEBUG, " Running % s with Verbose Mode " ,S9K_TOOL_NAME ) ;

MyGlobalsHandle . mOutObj . Print ( ERROR, " zResponseBuf is NULL ") ;

return VT_FALSE;

}

// bOk = MyGlobalsHandle . SetAllToolsParams () ;

// if (! bOk )

// {MyGlobalsHandle . mOutObj . Print ( ERROR, " SetAllToolsParams () Fail ") ;

// }

MyGlobalsHandle . mOutObj . Print ( DEBUG, " Running Tool % s " ,S9K_TOOL_NAME ) ;

// Execute S9ktool

obRet = ( VTBoolean ) pFuncExec () ;

if (! obRet ) MyGlobalsHandle . PrintLastVTError () ;

MyGlobalsHandle . mOutObj . Print ( DEBUG,

"--------------- End of TMN_S9KPutCompare ----------------- ") ;

// bOk = MyGlobalsHandle . GetAllToolsParams ( zResponseBuf ) ;

// if (! bOk ) MyGlobalsHandle . PrintLastVTError () ;

return obRet;

}

Example

//////////////////////////////////////////////////////////////////////////////

// \ A line starting with // \ is special comments for the Example . cpp program

// \ Following is the string that is used by our RCS automatic identifier :

// $GIFT - VT;Tool;generic$

// CExample . cpp

//

//****************************************************************************

// ( C ) COPYRIGHT INTEL CORPORATION . <2001> .

//

// You may not use, copy, modify, or transfer the program,

// or any copy, modification or merged portion, in whole,

// or in part,

// except as expressly provided for by license from Intel .

//

//****************************************************************************

//

// Contains : source for class CExample methods :

// Cto'r ( Constructor )

// Dto'r ( Destructor )

// CheckParams

// PrintHeader

// Execute

// RunTool

//

// V0 27 MAR 2001 Efi Rosental ?Creation?

// Author : Efi Rosental efi . [email_address] . com 04-865-5483

//

// Revision History : None

/*

* $Header : / afs / iil . intel . com / tmn / eng / tcg / TMN_TCG_4 / GIFT_FILES / Tools / Active / Aux / RCS / CExample . cpp,v 1.2 2001-02-19 02:20:52+02 cecp Exp $

* $RCSfile : CExample . cpp,v $

* $Revision : 1.2 $

* $Date : 2001-02-19 02:20:52+02 $

* $Id : CExample . cpp,v 1.2 2001-02-19 02:20:52+02 cecp Exp $

* $Log : CExample . cpp,v $

*/

//////////////////////////////////////////////////////////////////////////////

/////////////////////////// @@ #include <stdlib . h>

// \Every Tool should include this on, for interface to the IDC provided VT ( libVTfuncs . so )

#include <vtFunctions . h>

// \Tools that need to call IFs from the added VT, the libExampleVTfuncs . so in out example

#include <vtExampleFunctions . h>

#include <CTimer . h>

#include " CExample . h "

static char * rcsid = " $Id : CExample . cpp,v 1.2 2001-02-19 02:20:52+02 cecp Exp $ " ;

static char * rcsrev = " $Revision : 1.2 $ " ;

// \Functions should look to the outside world as C language functions .

extern " C " {

VTBoolean Example_Check ( ParamsContainer & Container, char * zResponseBuf ) ;

VTBoolean Example_Run ( ParamsContainer & Container, char * zResponseBuf ) ;

}

//--------------------------------------------------------------------

// \ Check function is a must in each Tool source file . It checkes the parameters

// \ received from the server and errors are reported back to the server .

// Example_Check

//

// Purpose : To run " check " on parmeters ( used by server ).

//--------------------------------------------------------------------

VTBoolean Example_Check ( ParamsContainer & Container, char * zResponseBuf )

{

// \

CExample MyExample ( Container ) ;

return MyExample . CheckParams ( zResponseBuf ) ;

}

//--------------------------------------------------------------------

// \Run function is a must in each Tool source file . It runs Tool algorithm .

// Example_Run

//

// Purpose : To run the tool ( used by server ).

//--------------------------------------------------------------------

VTBoolean Example_Run ( ParamsContainer & Container, char * zResponseBuf )

{

CTimer Timer;

CExample MyExample ( Container ) ;

return MyExample . RunTool ( zResponseBuf ) ;

}

//--------------------------------------------------------------------

// Cto'r ( Constructor )

//--------------------------------------------------------------------

CExample :: CExample ( ParamsContainer & Container ): CBaseTool ( Container )

{

// \ FillToolParams, defined in CBaseTool . cpp, takes all parameters send

// \ from the server, and initializes the parameters

VTBoolean bOk = FillToolParams () ;

if (! bOk )

mOutObj . Print ( ERROR, " CExample :: CExample () ") ;

}

//--------------------------------------------------------------------

// Dto'r ( Destructor )

//--------------------------------------------------------------------

CExample :: ~CExample ()

{

}

//--------------------------------------------------------------------

// RunTool

//

// Purpose : Call Execute () and print the tool header .

//--------------------------------------------------------------------

VTBoolean CExample :: RunTool ( char * zResponseBuf )

{

PrintHeader () ;

/////////////////////////////// @@ call Run, which will call Execute per pattern

VTBoolean obRet = Execute () ;

mOutObj . Print ( INFORMATION,

"--------------- End Example Tool run ----------------- ") ;

return obRet;

}

//--------------------------------------------------------------------

// Execute

//

// Purpose : Run the tool algorithm .

// In this case it is just creating the CAddressCalc .

//--------------------------------------------------------------------

VTBoolean

CExample :: Execute ()

{

char zStringToUse [ MAX_NAME_LENGTH ] ;

VTBoolean ReturnValue;

mOutObj . Print ( REGULAR, " This is just an Example Tool ") ;

// \ print out current Pattern name .

// \ The following vtGetCurrentPatternName IF is found in the IDC provided VT,

// \ the libVTfuncs . so Shared Object ( Shared Library ):

ReturnValue = vtGetCurrentPatternName ( zStringToUse ) ;

if ( ReturnValue == VT_FALSE ) {

PrintLastVTError () ;

return VT_FALSE;

}

mOutObj . Print ( INFORMATION, " Current Pattern Name % s " ,zStringToUse ) ;

// \ print out current Tester's Software release .

// \ This vtExampleRun IF is found in the Example VT,

// \ the libExampleVTfuncs . so Shared Library, dropped in the same place

// \ as the libVTfuncs . so . Please note that the libExampleVTfuncs . so accesses

// \ the libVTfuncs . so file ( refer to its source ) taking vital papareters fro there .

ReturnValue = vtExampleRun ( zStringToUse ) ;

if ( ReturnValue == VT_FALSE ) {

PrintLastVTError () ;

return VT_FALSE;

}

mOutObj . Print ( INFORMATION, " Tester version is : % s " ,zStringToUse ) ;

return VT_TRUE;

}

//--------------------------------------------------------------------

// PrintHeader

//

// Purpose : Prints the parameters description and values

//--------------------------------------------------------------------

VTBoolean

CExample :: PrintHeader ()

{

mOutObj . Print ( REGULAR, " ; Tool Example --- Begin Header ---") ;

// print CBaseTool parameters .

CBaseTool :: PrintHeader () ;

// print CExample tool parameters .

char zDescriptionBuf [ MAX_VALUE_CHARS ] ;

GetParamDescription ( FIRST_PARAM, zDescriptionBuf ) ;

mOutObj . Print ( REGULAR, " ; %-45s : % d " , zDescriptionBuf, mFirst ) ;

GetParamDescription ( SECOND_PARAM, zDescriptionBuf ) ;

mOutObj . Print ( REGULAR, " ; %-45s : % s " , zDescriptionBuf, msSecond . c_str ()) ;

GetParamDescription ( THIRD_PARAM, zDescriptionBuf ) ;

mOutObj . Print ( REGULAR, " ; %-45s : % d " , zDescriptionBuf, mThird ) ;

GetParamDescription ( OPTIONS, zDescriptionBuf ) ;

mOutObj . Print ( REGULAR, " ; %-45s : % d " , zDescriptionBuf, mOptions ) ;

GetParamDescription ( FIRST_OPTION, zDescriptionBuf ) ;

mOutObj . Print ( REGULAR, " ; %-45s : % d " , zDescriptionBuf, mFirstOption ) ;

GetParamDescription ( SECOND_OPTION, zDescriptionBuf ) ;

mOutObj . Print ( REGULAR, " ; %-45s : % d " , zDescriptionBuf, mSecondOption ) ;

mOutObj . Print ( REGULAR, " ; ------------------------------------------ ") ;

return VT_TRUE;

}

//--------------------------------------------------------------------

// CheckParams

//

// Purpose : check the parameters values received from the GUI .

// Output : print in to zResponseBuf the tool revition and an error

// message for each parameter found wrong .

// returns VT_FALSE if there is any .

//--------------------------------------------------------------------

VTBoolean

CExample :: CheckParams ( char * zResponseBuf )

{

// ERROR

return VT_FALSE;

}

sprintf ( zResponseBuf, "% s; " ,rcsrev ) ; // Return RCS rev

// Invoke CheckParams () of base classes

VTBoolean obRet = CBaseTool :: CheckParams ( zResponseBuf ) ;

// Then check the tool own parameters if any .

return obRet;

}

//--------------------------------------------------------------------

// FillToolParams

//

// Purpose : Get the parameters values from the GUI .

//--------------------------------------------------------------------

VTBoolean

CExample :: FillToolParams ()

{

char zValBuf [ MAX_VALUE_CHARS ] ;

try{

GetParamValue ( FIRST_PARAM, zValBuf ) ;

mFirst = atoi ( zValBuf ) ;

GetParamValue ( SECOND_PARAM, zValBuf ) ;

msSecond = zValBuf;

GetParamValue ( THIRD_PARAM, zValBuf ) ;

mThird = atoi ( zValBuf ) ;

GetParamValue ( OPTIONS, zValBuf ) ;

mOptions = atoi ( zValBuf ) ;

GetParamValue ( FIRST_OPTION, zValBuf ) ;

mFirstOption = atoi ( zValBuf ) ;

GetParamValue ( SECOND_OPTION, zValBuf ) ;

mSecondOption = atoi ( zValBuf ) ;

}

catch ( char * zError ) {

mOutObj . Print ( ERROR, "% s " ,zError ) ;

return VT_FALSE;

}

return VT_TRUE;

}

Gift-VT Tools Development Overview

0 comments

Notes on slide 1

Favorites, Groups & Events