Version 1.1 Update
[ctprof_srv/ctprof_srv.git] / example_app / ctprof_ex.c
1 /*
2  * ctprof_ex.c
3  *
4  * Ctools Profiler Example Implementation
5  *
6  * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.com/ 
7  * 
8  * 
9  *  Redistribution and use in source and binary forms, with or without 
10  *  modification, are permitted provided that the following conditions 
11  *  are met:
12  *
13  *    Redistributions of source code must retain the above copyright 
14  *    notice, this list of conditions and the following disclaimer.
15  *
16  *    Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the 
18  *    documentation and/or other materials provided with the   
19  *    distribution.
20  *
21  *    Neither the name of Texas Instruments Incorporated nor the names of
22  *    its contributors may be used to endorse or promote products derived
23  *    from this software without specific prior written permission.
24  *
25  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
26  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
27  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
29  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
30  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
31  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
34  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
35  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36  *
37 */
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <stdbool.h>
42 #include <getopt.h>
43 #include <stdint.h>
44 #include <sys/mman.h>
45 #include <fcntl.h>
46 #include "ctprof_utility.h"
48 const int g_major_version = 1;
49 const int g_minor_version = 1;
50 const int g_copyright_year = 2013;
52 FILE *g_stdout;
53 FILE *g_stderr;
54 char * g_whoami;
56 struct memory_blk_t{
57     char * name;
58     uint32_t phy_addr;
59     void * v_addr;
60     size_t phy_size;
61 }; 
63 struct memory_blk_t memory_table[] = {
64     {"Corepac L2_0", 0x10800000, 0, 1024*1024}, /* Corepac 0 L2 */
65     {"Corepac L2_1", 0x11800000, 0, 1024*1024}, /* Corepac 1 L2 */
66     {"Corepac L2_2", 0x12800000, 0, 1024*1024}, /* Corepac 2 L2 */
67     {"Corepac L2_3", 0x13800000, 0, 1024*1024}  /* Corepac 3 L2 */
68 };
70 const int zero_test_words = 65536;
71 const int memory_table_elements = sizeof(memory_table)/sizeof(struct memory_blk_t);
73 static struct option long_options[] = {
74     {"interations", required_argument, 0, 'i'},
75     {"pipe", no_argument, 0, 'P'},
76     {"quiet", no_argument, 0,'q'},
77     {"help", no_argument, 0, 'h'},
78     {"version", no_argument, 0, 'v'}
79 };
81 static char * short_options = "i:qhvP";
83 static int test_iterations = 1;
84 static bool pipe_enable = false;
86 int main(int argc, char *argv[])
87 {
88     /* Intialize globals */
89     g_stdout = stdout;
90     g_stderr = stderr;
91     g_whoami = argv[0];
93     /* evaluate commamnd line */
94     while (1) {
96         int option, option_index = 0;
98         option = getopt_long(argc, argv, short_options, long_options, &option_index);
99         
100         if (option == -1) break;
102         switch (option) {
103         case 'i':
104             test_iterations = atoi(optarg);
105             break;
106         case 'q':
107             g_stdout = fopen("/dev/null", "w");
108             break;
109         case 'h':
110             fprintf(g_stdout, "Usage: ctprof_ex [ihqv]\n");
111             fprintf(g_stdout, " --iterations/-i <n>     Run test n times\n");
112             fprintf(g_stdout, " --pipe/-P               Use pipe to coordiante with ctprof_srv\n");
113             fprintf(g_stdout, " --help/-h               Print this\n");
114             fprintf(g_stdout, " --quiet/-q              Send stdout to /dev/null\n");
115             fprintf(g_stdout, " --version/-v            Print version\n");
116             fprintf(g_stdout, "\n");
117             exit(0);
118         case 'P':
119             pipe_enable = true;
120             break;
121         case 'v':
122             fprintf(g_stdout, "ctprof_ex version %d.%d\n", 
123                                              g_major_version, g_minor_version);
124             fprintf(g_stdout, "Copyright (C) %d Texas Instruments, Inc.\n", 
125                                                              g_copyright_year); 
126             exit(0);
127         default:
128             fprintf(g_stderr,"Invalid option - try -h\n");
129             exit(0); 
130         } /* End of switch */
132     }/* end of while*/
134     /************************************************************/
135     /* Wait until ctprof is recording to start                  */
136     /************************************************************/
137     if (pipe_enable) {
138         if (ctprof_pipe_open() == -1) {
139             fprintf(g_stderr, "Can't open pipe to ctprof\n");
140             exit(-1);
141         }
142  
143         ctprof_ready_wait();
144         ctprof_start_recording();
145         ctprof_recording_wait();
146     }
147     /************************************************************/
148     /* Map each memory table element                            */
149     /************************************************************/
150     int mem_fd = open("/dev/mem", O_RDWR | O_SYNC | O_RSYNC );
151     if (mem_fd == -1) {
152         fprintf(g_stderr, "Can't open /dev/mem\n");
153         exit(-1);
154     }
156     for (int i = 0; i <  memory_table_elements; i++) {
157         memory_table[i].v_addr = mmap(0, memory_table[i].phy_size, 
158                                        PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd, 
159                                        memory_table[i].phy_addr);
161         mlock(memory_table[i].v_addr, memory_table[i].phy_size); 
162     }   
164     /************************************************************/
165     /* Test Loop                                                */
166     /************************************************************/
167     while (test_iterations != 0) {
169         fprintf(g_stdout, "\r%s:Test Iterations left %d\n", g_whoami, test_iterations);
171         /* This test writes zero to the first 64K words of each memory_table element */
172         for (int i = 0; i <  memory_table_elements; i++) {
174             if (pipe_enable) {
175                 if (i == 2) {
176                     ctprof_end_recording();
177                     ctprof_stopped_wait();
178                 }
179             }
181             fprintf(g_stdout, "\r%s:Testing %d words of %s\n", g_whoami, zero_test_words, memory_table[i].name);
183             uint32_t * addr = (uint32_t *)memory_table[i].v_addr;
184             for (int n = 0; n < zero_test_words; n++) {
185                  *addr++ = 0;
186             }
188             addr = (uint32_t *)memory_table[i].v_addr;
189             int test_failed_cnt = 0;
191             for (int n = 0; n < zero_test_words; n++) {
192                  if (*addr++ != 0 ) {
193                     test_failed_cnt++;
194                 }
195             }
197             fprintf(g_stdout, "\r%s:%s had %d failures\n", g_whoami, memory_table[i].name, test_failed_cnt);           
199         }
200         test_iterations--;
202     } /* End of while*/
204     if (pipe_enable) {
205         ctprof_pipe_close();
206     }
207     fprintf(g_stdout, "\r%s:Exiting\n", g_whoami);
208     exit(0);