Trace without a Trace Port on MSC8156 and MSC8144 DSPs

Transcription

1 July 2009 Trace without a Trace Port on MSC8156 and MSC8144 DSPs Using HEAT -- With SC10 build #48 and MSC8156ADS Irene Sierra

2 Summary HEAT concept HEAT HW setup HEAT architecture HEAT API HEAT server HEAT usage HEAT usage for fast VTB download 2

3 HEAT Concept Host Exchange Asynchronous Transfer 3

4 HEAT Concept The problem: The JTAG interface together, with the implementation of the stdio.h functionalities in CodeWarrior, pose a real-time performance problem for communication between ADS and PC. Available hardware and software support to override the problem: Freescale DSPs available 10/100/1000 Ethernet port SmartDSP OS kernel, drivers and IP stack Solution: An application layer development, running over UDP/IP with file IO specific API => HEAT 4

5 HEAT Hardware Setup Setting up the MSC8156ADS board for HEAT 5

6 1. Configure the board for dip switches according to the MSC8156ADS quick start guide. SW5.5 has to be changed to RGMII (ON). HEAT HW Setup 2. Ensure there is a GETH network cable connected to the RJ45 J8 connector. 3. Ensure the other end of the GETH cable is connected to the GETH card of the PC or switch. 4. Configure the host PC IP or MSC8156 IP accordingly. 6

7 HEAT Architecture A file IO client server application 7

8 HEAT Architecture HEAT is a client-server application: HEAT client residing on the DSP, runs over SmartDSP OS and uses both SmartDSP OS kernel and the Ethernet driver. The client can issue requests to multiple servers. HEAT API is as similar as possible to the stdio.h API. HEAT server residing on a remote PC. The server(s) can handle requests from multiple clients. Each request is decoded and handled using a stdio.h defined function. 8

9 HEAT Architecture HEAT features: Can be used for sending files with full path on the host PC (chdir capabilities) Can be used for streaming large data to/from PC a transfer that takes hours on JTAG takes seconds on HEAT Integrated with CodeWarrior Software Analysis can be used for sending large profiling and debugging info to host/development PC Can be used for sending debug messages directly on HEAT server console with printf s the target won t stop anymore the execution in debug traps 9

10 HEAT architecture HEAT features: The application layer, running over UDP/IP, is both simple and versatile. It can easily be enhanced to support further additions to the HEAT library. It just uses an MSC8156 ethernet port NOT locking it (UEC port still shareable between cores and other applications). Low overhead on the application. Multicore capable and useable. The heat_demo example in SC10 proves all these multicore, file transfer and console debug capabilities. 10

11 HEAT architecture HEAT performance: JTAG and HSST performance Over 150x faster that JTAG. HEAT performance is so big, that it couldn t be represented on the same chart with JTAG. HSST data are used for reference between JTAG and HEAT. It is recommended to use SmartDSP HEAT whenever you can. packets/sec , Packet size 6, ,000 JTAG(small buffer) HSST(small buffer) JTAG(medium buffer) HSST(medium buffer) JTAG(large buffer) HSST(large buffer) JTAG(big buffer) HSST(big buffer) An optimal size for a packet is considered at 10Mbyte, beyond that limit hardware may slow down communication due disk data management issues. Note: Tests were done on 8144ADS with core Rev2 but this shouldn t affect the comparison results. MSC8156 tests will follow. packets/sec 250, , , ,000 50, HSST and SmartDSP HEAT performance 218, ,000 HSST(small buffer) SmartDSP HEAT(small buffer) 147,000 HSST(medium buffer) SmartDSP HEAT(medium buffer) HSST(large buffer) SmartDSP HEAT(large buffer) HSST(big buffer) SmartDSP HEAT(big buffer) 6,167 3,750 6,000 8,000 Packet size 11

12 HEAT API As similar as possible to the stdio.h API 12

13 HEAT API Freescale HEAT protocol implementation provides support for its API with stdio hooks enabled. Use printf() within code and see the output on server console Use fopen() and fclose() to open/close a remote file Use fread() or fwrite() to read or write from/in a remote file Use ftell() to get the position in the file Use fseek() to reposition the position indicator in the remote file 13

14 HEAT API HEAT conceptual entities HEAT provided functions Standard C File IO functions are fully available Functions HEAT Initialization HEAT Initialization HEAT File IO Wrapped standard functions HEAT Control osheatinitialize() osheatopen() fopen() HEAT File IO osheatstdioinitialize() heatopen() fclose() osheatclose() fread() Data Structures HEAT Connection HEAT Control osheatwrite() osheatread() fwrite() ftell() HEAT File Info osheatcallback() osheattell() fseek() HEAT Initialization osheatnull() osheatseek() printf() 14

15 HEAT API HEAT data structures: HEAT connection data structure contains info about the socket and server address and port HEAT file info data structure contains a file handle, cookie for synchronization between machines, semaphore for file protection, connection handle, response handlers, buffer for read operations HEAT initialization parameters data structure contains info regarding number of file handles allowed, timeouts, heap allocation, maximum packet size, polling info, send retries number 15

16 HEAT API Network settings and defines that HEAT uses in a very simple manner - Define gateway IP, own IP and server IP address: #define DEFAULT_GATEWAY_IP_ADDRESS #define MY_IP_ADDRESS #define SERVER_IP_ADDRESS 0x0A00008A 0x0A x0A Define MAC: #define MY_MAC_ADDR_HIGH32 0xc2c3c4c5 #define MY_MAC_ADDR_LOW16 0xc6c7 - Define UDP port: #define HEAT_UDP_PORT

17 HEAT API HEAT functions the names are relevant /* Initialization */ os_status osheatinitialize(struct heat_init_params_t *heat_init_params); void osheatstdioinitialize(struct heat_connection_t* connection, bool sync_write); /* Control */ os_status osheatcallback(void* p, os_frame_t* frame); os_status osheatnull(struct heat_connection_t* connection); /* File operations */ struct heat_file_t* osheatopen(const char *filename, const char *mode, struct heat_connection_t* connection, bool sync_write); int32_t osheatclose(struct heat_file_t* file); int32_t osheatwrite(const void* ptr, uint32_t size, uint32_t nitems, struct heat_file_t* file); int32_t osheatread(void *ptr, uint32_t size, uint32_t nitems, struct heat_file_t* file); int32_t osheattell(struct heat_file_t* file); int32_t osheatseek(struct heat_file_t* file, uint32_t offset, uint32_t origin); FILE* heatopen( const char* filename, const char* mode, struct heat_connection_t* connection, bool sync_write); 17

18 HEAT server What is happening on the PC? 18

19 HEAT server The received data is stored in files and formats as designated from client application. The files can be further managed on server machine. It is provided precompiled for immediate use and in sources for customization. It can be executed as is, with default parameters or with the following parameters (use heat_server.exe help to see this): <SC_10_root_dir>\StarCore_Support\SmartDSP\tools\heat_server>heat_server.exe --help Allowed options: --help produce help message --thread-count arg (=6) set maximum number of threads for server(defaults to 6) --bind-ip arg bind ip(defaults to ) --port arg (=1254) port number(defaults to 1254) --log arg (=info) log level[error, info, debug](defaults to error) --log-file arg (=log.txt) log file[error, info, debug](defaults to log.txt) 19

20 HEAT Usage How to use HEAT to print on server console and to transfer unlimited data on server host machine 20

21 HEAT Usage The bottom communication principle stands on service request response messaging. To do that, each HEAT packet has a header. The service request header is divided into 3 sections: A uint32 HEAT library enumeration associated with the service type requested. A uint32 cookie. The emulated functions API parameters. Service Request Requested service type info Communication synchro cookie Emulated function parameters For each service request, the server responds with a response packet. The response packet includes the following information: A uint32 byte HEAT library enumeration associated with the service type requested. A uint32 cookie associated with the HEAT file handle. The emulated functions return value. HEAT Client Response Requested service type info Communication synchro cookie Emulated function return value HEAT Server 21

22 HEAT usage Needed libraries When writing an application it is recommended that the general guidelines in the SmartDSP OS documentation to be read. In order to use HEAT the following libraries must be included: *All related to MSC8156 Production Debug SDOS drivers library SDOS runtime and common HEAT library Net support library BSP library os_msc8156_drivers.elb os_msc8156.elb 3850_heat_lib.elb net_lib_sc3850.elb bsp_msc8156ads.elb os_msc8156_drivers_debug.elb os_msc8156_debug.elb 3850_heat_lib_debug.elb net_debug_sc3850.elb bsp_msc8156ads_debug.elb 22

23 HEAT usage Initialization The PC HEAT server can be started before a network connection is establishes and it will try to bind repeatedly, every second, until it succeeds. In order to use HEAT, the ADS program must set up the hardware to use UDP. HEAT initialization routine can be spliced in five stages: 23

24 HEAT usage SDOS driver layer SDOS protocol layer SDOS application layer 1 Setup memory 3 Setup TCP/IP 5 Init HEAT Create Frame pool Create an Interface Initialize HEAT parameters osframepoolcreate(); ifcreate(); osheatinitialize(); Create Buffer pool Set the gateway Initialize HEAT for console osmempartcreate(); insetdefgateway(); osheatconsoleinitialize(); Set local IP address Initialize HEAT for stdio 2 Setup UEC driver insetaddr(); osheatstdioinitialize(); Allocate MAC initchannelmacipaddress(); 4 Setup UDP Set MSC8156 UEC 0 or 1 Init UDP module osbiodeviceopen(); udpinit(); Open Rx/Tx channels on UEC Create UDP socket osbiochannelopen(); Synchronize cores udpsocket(); Bind the socket to the address Start using HEAT oswaitforallcores(); udpbind(); Enable UEC Setup UDP callback function osbiodevicectrl(); insetudpcallback(); 24

25 HEAT usage Some HEAT usage examples Initialize HEAT, HEAT server console for printf output and HEAT stdio for stdio alike file IO functions Start using HEAT IO and standard FILE IO functions as you wish sprintf(char* console_buf, Printed on server console with HEAT write function\n"); osheatwrite(console_buf, 1, strlen(console_buf), HEAT_STDOUT); osheatinitialize() osheatconsoleinitialize() osheatstdioinitialize() printf( This text will appear on server console\n"); FILE* f = fopen( c:\testfile.txt, "wt", &server_connection, TRUE); fwrite( Writing this 45 characters in the opened file,1,/*strlen*/45,/*file handle*/f); SDOS appinit() function SDOS appbackground() function or in other routines called from appbackground() function 25

26 HEAT usage for fast VTB download Software Analysis 26

27 HEAT usage for fast VTB download Project setup Start with Step 1 or override it and starting from an existing MSC8156ADS SDOS based project and continue from Step 2. Step 1: Use SC 10 wizard to create a new MSC8156ADS project with SDOS support the Basic demo project will be loaded. Step 2: Add to the project the following files located in \<SC_10_root_dir>\StarCore_Support\SoftwareAnalysis\swandemo_8156ads_heat: app_config_sa.h data_buffers.c msc815x_config.c (overwrite or delete the existing one) sa_handle.c Step 3: Edit app_config_sa.h and set network parameters as in the example below on your network settings. The net mask will be automatically set by SDOS according to its class. #define DEFAULT_GATEWAY_IP_ADDRESS 0xC0A8008A /* */ #define MY_IP_ADDRESS 0xC0A80001 /* */ #define SERVER_IP_ADDRESS 0xC0A80064 /* */ 27

28 HEAT usage for fast VTB download Step 4: Browse in the properties of the project as in the figure below and add all the figure presented libraries to the linker in your project. The paths are relevant. 28

29 HEAT usage for fast VTB download Step 5: To override missing included headers errors, load <SC_10_root_dir>\StarCore_Support\SmartDSP\include\heat and <SC_10_root_dir>\StarCore_Support\SmartDSP\include\net paths to HEAT and NET file headers in preprocessor. Include paths located in project properties settings window as in figure below. 29

30 HEAT usage for fast VTB download Step 6: Modify basic.demo.c file or your project file containing the main(), appinit() and appbackground() as follows: add: #include "app_config_sa.h add in appinit() function the next code to create the HWI for SA: status = oshwicreate(os_int_dpua,os_hwi_priority_nmi,edge_mode,sa_ter_handle,0); OS_ASSERT_COND(status == OS_SUCCESS); Step 7: Modify os_config.h as follows: Uncomment: //#define OS_SHARED_MEM_DDR0_SIZE 0x3000 Modify the next items as bellow: #define OS_TOTAL_NUM_OF_MEM_PARTS 8 /* Memory Partitions */ #define OS_TOTAL_NUM_OF_FRAME_POOLS 8 /* Frame Pools Number*/ #define OS_TOTAL_NUM_OF_SWI 10 /* Software Interrupts Number */ #define OS_TOTAL_NUM_OF_QUEUES 48 /* Queues Number */ /*MA*/ Add some semaphores: #define OS_TOTAL_NUM_OF_EVENT_SEMAPHORES 15 /*semaphores*/ Restrict number of cores to 1 SA through HEAT is not yet implemented on multicore: #define OS_NUM_OF_CORES 1 /* Cores Number*/ Enable UEC 0 (giga ethernet interface) in BIO devices: #define MSC815X_UEC0 ON #define OS_TOTAL_NUM_OF_BIO_DEVICES 1 30

31 HEAT usage for fast VTB download Step 8: Build the project. It is possible to get linker errors. If starting from BasicDemo project, it is possible to get an alignment or overlap linking error in M3. Edit the memory map file specified below to increase local M3 memory size: D:\_SC_10_\SC_10.0\StarCore_Support\SmartDSP\demos\starcore\msc815x\basic_ demo\linker_files\memory_map_link.lcf: ;////////////// M3 Memory definitions /////////////////// ;Physical address and size for M3 Local and Shared Memory ;One to one mapping in the 32KB segment of M3.provide _LocalDataM3_b, _M3_b ;.provide _LocalDataM3_size,0x10000 ; 64 KB of M3 comment this line.provide _LocalDataM3_size,0x20000 ; 128 KB of M3 add this line Step 9: Verify host PC network settings and start HEAT server on remote PC with desired parameters. It should work if launched with default parameters. 31

32 Step 10: - Open Debug Configurations : - Select the appropriate debug configuration target - Go to Trace and Profile tab - Check Enable Trace and Profiling checkbox - Select SmartDSP HEAT for Trace Offload Method - Set VTB settings and Counted Events as usually done for JTAG based Software Analysis Step 11: Click Apply then Debug HEAT usage for fast VTB download 32

33 HEAT usage for fast VTB download Step 12: In the debug window, go to main() function to the line containing: status = osstart(appbackground); Right click on the left bar and choose Toggle Trace Start Point from the menu. Step 13: Click Resume button. Step 14: the results are collected by default in the file c:\sa_ter_heat.txt. It shouldn t be touched by the developer. This file is automatically processed by the software analysis engine. The developer should follow the normal way for browsing the profiling data (as done in JTAG based SA). 33

34 HEAT VTB transport principle: HEAT usage for fast VTB download The VTB is collected in a buffer in a free memory region as designated in VTB settings sa_ter_handle() interrupt occurs when the buffer is full and it is mainly responsible for: Creating the sa_ter_heat.txt file on the host PC Reading the buffer and sending its content to the PC Managing profiling start/stop during VTB transport 34

35 Get Support The official support channel is here. 35

36 ANNEX 1 Demo: HEAT project useful to adapt for large files transport: D:\_SC_10_\SC_10.0\StarCore_Support\SmartDSP\demos\starcore\msc815x\heat_demo Demo: HEAT for fast VTB download: D:\_SC_10_\SC_10.0\StarCore_Support\SoftwareAnalysis\swandemo_8156ads_heat HEAT Source files location: D:\_SC_10_\SC_10.0\StarCore_Support\SmartDSP\source\heat 36

37 Q&A Thank you for attending this presentation. We ll now take a few moments for the audience s questions and then we ll begin the question and answer session. 37

38