gmane.linux.ltp

[PATCH] Perform the test in a private directory

Roy Lee — 2008-12-02T01:12:56

This test case requires write permission for the dummy program. It would fail for those who put LTP on an read-only environment. So this patch copies the dummy test program to and performs the test in a private directory. p.s. this patch copy the one Renaud Lottiaux sent for execve02.c. --- testcases/kernel/syscalls/execve/execve05.c | 47 +++++++++++++++++++++++++++ 1 files changed, 47 insertions(+), 0 deletions(-) diff --git a/testcases/kernel/syscalls/execve/execve05.c b/testcases/kernel/syscalls/execve/execve05.c index 8952d6f..ec23a43 100644 --- a/testcases/kernel/syscalls/execve/execve05.c +++ b/testcases/kernel/syscalls/execve/execve05.c < at >< at > -55,6 +55,7 < at >< at > #include #include #include +#include #include "test.h" #include "usctest.h" #include "libtestsuite.h" < at >< at > -212,9 +213,52 < at >< at > help() void setup() { +char *cmd, *dirc, *basec, *bname, *dname, *path, *pwd = NULL; +int res; + /* capture signals */ tst_sig(FORK, DEF_HANDLER, cleanup); +/* Get file name of the passed test file and the absolute path to it. + * We will need these informations to copy the test file in the temp + * directory. + */ +dirc = strdup(test_name); +basec = strdup(test_name); +dname = dirname(dirc); +bname = basename(basec); + +if (dname[0] == '/') +path = dname; +else { +if ((pwd = getcwd(NULL, 0)) == NULL) { +tst_brkm(TBROK, tst_exit, "Could not get current directory"); +} +path = malloc (strlen(pwd) + strlen(dname) + 2); +if (path == NULL) { +tst_brkm(TBROK, tst_exit, "Cannot alloc path string"); +} +sprintf (path, "%s/%s", pwd, dname); +} + +/* make a temp dir and cd to it */ +tst_tmpdir(); + +/* Copy the given test file to the private temp directory. +*/ +cmd = malloc (strlen(path) + strlen(bname) + 15); +if (cmd == NULL){ +tst_brkm(TBROK, tst_exit, "Cannot alloc command string"); +} + +sprintf (cmd, "cp -p %s/%s .", path, bname); +res = system (cmd); +free (cmd); +if (res == -1) { +tst_brkm(TBROK, tst_exit, "Cannot copy file %s", test_name); +} + +test_name = bname; /* Pause if that option was specified */ TEST_PAUSE; } < at >< at > -233,6 +277,9 < at >< at > cleanup() */ TEST_CLEANUP; +/* Remove the temporary directory */ +tst_rmdir(); + /* exit with return code appropriate for results */ tst_exit(); }

Re: [RFC] Testing Support for FILECAPS improvements in 2.6.27

Serge E. Hallyn — 2008-12-01T18:04:57

Quoting Subrata Modak (subrata-23VcF4HTsmIX0ybBhKVfKdBPR1lH4CV8< at >public.gmane.org): That probably ranks lower priority than the securebits tests. That should be tested by existing tests. It's a code refactoring, not a new feature. thanks, -serge ------------------------------------------------------------------------- This SF.Net email is sponsored by the Moblin Your Move Developer's challenge Build the coolest Linux based applications with Moblin SDK & win great prizes Grand prize is a trip for two to an Open Source event anywhere in the world http://moblin-contest.org/redirect.php?banner_id=100&url=/

fails in syscalls/stat04_64 and syscalls/lstat01A_64 testcases

Dmitry Guryanov — 2008-12-01T17:55:54

Hi, stat04 and lstat01A are testcases of symlink01 test: from runtest/syscalls: lstat01A symlink01 -T lstat01 lstat01A_64 symlink01 -T lstat01_64 ... stat04 symlink01 -T stat04 stat04_64 symlink01 -T stat04_64 symlink01 test has no testcases with name lstat01_64 and stat04_64, so this testcases fail now. What can we do with this ?

Re: problems with signalfd testcase on different systems

Dmitry Guryanov — 2008-12-01T16:44:03

thanks

[PATCH 1/4] [RT][RFC][Take#5] New library: libxml

Gilles Carry — 2008-12-01T15:10:35

This library provides a set of function to help the saving of data as XML formatted files. Note: this is a lightweight library as it does not check if the document is well formed or grammaticallt correct. It must be considered as a commodity that helps tag indentation and avoids user to toss with '<' and '>'. To embbed it into executables, run: XML_LIB=1 make Also, it adds heading tags with data such as timestamp, system information, test conditions... This to facilitate post processing. (eg. further comparisons of different testruns, formatting for plotting...) This patch does not alter the LTP/RT traditional stats dump. A new global command line option is used: -x Compilation is conditional to LIB_XML. Signed-off-by: Gilles Carry public.gmane.org> --- testcases/realtime/config.mk | 5 + testcases/realtime/include/libxml.h | 134 ++++++++++++ testcases/realtime/lib/librttest.c | 23 ++- testcases/realtime/lib/libxml.c | 385 +++++++++++++++++++++++++++++++++++ 4 files changed, 545 insertions(+), 2 deletions(-) create mode 100644 testcases/realtime/include/libxml.h create mode 100644 testcases/realtime/lib/libxml.c diff --git a/testcases/realtime/config.mk b/testcases/realtime/config.mk index 19ccddc..0570a2e 100644 --- a/testcases/realtime/config.mk +++ b/testcases/realtime/config.mk < at >< at > -18,6 +18,11 < at >< at > endif # CPPFLAGS += -I$(srcdir)/include -D_GNU_SOURCE CFLAGS += -Wall +ifdef LIB_XML +LDLIBS += $(srcdir)/lib/libxml.o +CFLAGS += -DLIB_XML +endif + LDLIBS += $(srcdir)/lib/libjvmsim.o \ $(srcdir)/lib/librttest.o \ $(srcdir)/lib/libstats.o \ diff --git a/testcases/realtime/include/libxml.h b/testcases/realtime/include/libxml.h new file mode 100644 index 0000000..715eb7c --- /dev/null +++ b/testcases/realtime/include/libxml.h < at >< at > -0,0 +1,134 < at >< at > +/****************************************************************************** + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + * the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * NAME + * libxml.h + * + * DESCRIPTION + * Lightweight xml functions + * + * USAGE: + * To be linked with testcases + * + * AUTHOR + * Gilles Carry public.gmane.org> + * + * HISTORY + * 2008-Oct-20: Initial version by Gilles Carry + * + * TODO: + * + *****************************************************************************/ + +#ifndef LIBXML_H +#define LIBXML_H + +#include +#include +#include +#include +#include + +#defineTAGNAME_MAX_SIZE100 + +/* Flags for new tags */ +#define XML_TAG_SC0x1U/* Self-close tag */ +#define XML_TAG_NOCR0x2U/* No carriage return after markup */ +#define XML_TAG_NOIND0x4U/* No indentation */ + +#define xml_start_tag(stream,tagname)xml_tag(stream, 0, tagname, NULL) +#define xml_sc_tag(stream,tagname)xml_tag(stream, XML_TAG_SC, tagname, NULL) +#define xml_start_tag_watrr(stream,tagname,...)xml_tag(stream, 0, tagname, __VA_ARGS__) +#define xml_sc_tag_watrr(stream,tagname,...)xml_tag(stream, XML_TAG_SC, tagname, __VA_ARGS__) +#define xml_end_tag(stream)xml_end(stream, 0) +#define xml_entry(stream,tagname,...) \ +do { \ +xml_tag(stream, XML_TAG_NOCR, tagname, NULL); \ +xml_content(stream, __VA_ARGS__); \ +xml_end(stream, XML_TAG_NOIND); \ +} while (0) + +typedef struct xml_stack_tag { +char tagname[TAGNAME_MAX_SIZE]; +} xml_stack_tag_t; + +typedef struct xml_stream { +FILE * fd; +int indent_level; +xml_stack_tag_t * stack; +int stack_size; +} xml_stream_t; + +extern char *test_name; +extern char *xml_free_user_id; +extern int xml_dump; + +/* + Generic function to write a start or selfclosing tag into an xml stream: + * + * or + * + * or + * + * or + * + * + * xs: xml stream to write to + * flags: + *XML_TAG_SC: self-close tag (no indentation increase and no end_tag) + *XML_TAG_CR: carriage return after markup + * tagname: xml markup name + * attr_fmt, ...: printf style argument for attributes + *no attribute if attr_fmt==NULL or attr_fmt is an empty string + */ +void xml_tag(xml_stream_t *xs, unsigned int flags, char *tagname, char *attr_fmt, ...); + +/* + * Write an end tag into an xml stream: + * + * + * xs: xml stream to write to + * flags: + *XML_TAG_NOIND: do not indent tag + */ +void xml_end(xml_stream_t *xs, unsigned int flags); + +/* + * Write data to xml stream + * + * xs: xml stream to write to + * fmt, ...: printf style formatting + */ +void xml_content(xml_stream_t *xs, char *fmt, ...); + +/* + * Create XML stream file and initialize headers. + * testname: name of the test + * root_tag: tag of root element + * title: title of the XML stream + * + * return: xml_stream_t pointer to be reused by subsequent xml_... calls. + */ +xml_stream_t * xml_stream_init(char *testname, char *root_tag, char *title); + +/* + * Close XML stream. + * + */ +void xml_stream_close(xml_stream_t *xs); + + +#endif /* LIBXML_H */ diff --git a/testcases/realtime/lib/librttest.c b/testcases/realtime/lib/librttest.c index e42fc84..71971d3 100644 --- a/testcases/realtime/lib/librttest.c +++ b/testcases/realtime/lib/librttest.c < at >< at > -41,6 +41,9 < at >< at > *****************************************************************************/ #include +#ifdef LIB_XML +#include +#endif #include #include < at >< at > -79,6 +82,10 < at >< at > void rt_help(void) printf(" -p(0,1)0:don't use pi mutexes, 1:use pi mutexes\n"); printf(" -v[0-4]0:no debug, 1:DBG_ERR, 2:DBG_WARN, 3:DBG_INFO, 4:DBG_DEBUG\n"); printf(" -sEnable saving stats data (default disabled)\n"); +#ifdef LIB_XML +printf(" -x Enable saving of outputs into xml file (default disabled)\n"); +printf(" user_free_id (mandatory arg) string inserted into xml dump\n"); +#endif printf(" -cSet pass criteria\n"); } < at >< at > -105,7 +112,11 < at >< at > int rt_init(const char *options, int (*parse_arg)(int option, char *value), int opterr = 0; char *all_options; -if (asprintf(&all_options, ":b:p:v:sc:%s", options) == -1) { +if (asprintf(&all_options, ":b:p:v:sc:" +#ifdef LIB_XML +"x:" +#endif +"%s", options) == -1) { fprintf(stderr, "Failed to allocate string for option string\n"); exit(1); } < at >< at > -123,7 +134,7 < at >< at > int rt_init(const char *options, int (*parse_arg)(int option, char *value), int exit(1); } } - + while ((c = getopt(argc, argv, all_options)) != -1) { switch (c) { case 'c': < at >< at > -141,6 +152,14 < at >< at > int rt_init(const char *options, int (*parse_arg)(int option, char *value), int case 's': save_stats = 1; break; +#ifdef LIB_XML +case 'x': +xml_dump = 1; +xml_free_user_id = optarg; +if (!strcmp("", xml_free_user_id)) +return -1; +break; +#endif case ':': fprintf(stderr, "option -%c: missing arg\n", optopt); parse_arg('h', optarg); /* Just to display usage */ diff --git a/testcases/realtime/lib/libxml.c b/testcases/realtime/lib/libxml.c new file mode 100644 index 0000000..51cfe6a --- /dev/null +++ b/testcases/realtime/lib/libxml.c < at >< at > -0,0 +1,385 < at >< at > +/****************************************************************************** + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See + * the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * NAME + * libxml.c + * + * DESCRIPTION + * Lightweight xml functions + * + * + * USAGE: + * To be linked with testcases + * + * AUTHOR + * Gilles Carry public.gmane.org> + * + * HISTORY + * 2008-Oct-20: Initial version by Gilles Carry + * + * TODO: + * + *****************************************************************************/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#defineTAG_STACK_INIT_SIZE100 + +char *xml_free_user_id = ""; +int xml_dump = 0; + + +/* + * Fetch information across /sys to provide the cpu topology + * of the system. + */ +static void xml_get_cpu_topology(xml_stream_t * xs) +{ +DIR *directory_parent, *directory_node; +struct dirent *de,*dn; +char directory_path[255]; +char *sys_dir; +char *ts_fname="thread_siblings_list"; +char buf[200]; + +xml_start_tag(xs, "sys"); +xml_start_tag(xs, "devices"); +xml_start_tag(xs, "system"); + +xml_start_tag(xs, "node"); + +sys_dir = "/sys/devices/system/node"; +directory_parent = opendir(sys_dir); +if (!directory_parent) { +xml_tag(xs, XML_TAG_SC, "not-numa", NULL); +} else { +while ((de = readdir(directory_parent)) != NULL) { +if (strncmp(de->d_name, "node", 4)) +continue; + +/* Check if string matches /node[0-9]/ */ +if (!isdigit(de->d_name[4])) +continue; + +xml_start_tag(xs, de->d_name); /* */ + +sprintf(directory_path, "%s/%s",sys_dir, de->d_name); +directory_node = opendir(directory_path); +if (!directory_parent) { +fprintf(stderr, "Unable to open dir %s: %s\n", directory_path, strerror(errno)); +continue; +} +while ((dn = readdir(directory_node)) != NULL) { +if (strncmp(dn->d_name, "cpu", 3)) +continue; + +if (!isdigit(dn->d_name[3])) +continue; + +xml_tag(xs, XML_TAG_SC, dn->d_name, NULL); /* */ +} +xml_end_tag(xs); /* nodeX */ +closedir(directory_node); +} +closedir(directory_parent); +} +xml_end_tag(xs); /* node */ + + +xml_start_tag(xs, "cpu"); +sys_dir = "/sys/devices/system/cpu"; +directory_parent = opendir(sys_dir); +if (!directory_parent) { +fprintf(stderr, "Unable to open dir %s: %s\n", sys_dir, strerror(errno)); +exit(EXIT_FAILURE); +} +while ((de = readdir(directory_parent)) != NULL) { + +if (strncmp(de->d_name, "cpu", 3)) +continue; + +/* Check if string matches /node[0-9]/ */ +if (!isdigit(de->d_name[3])) +continue; + +sprintf(directory_path, "%s/%s/topology",sys_dir, de->d_name); +directory_node = opendir(directory_path); +if (!directory_node) { +/* Cpu probably offline */ +continue; +} +xml_start_tag(xs, de->d_name); + +xml_start_tag(xs, "topology"); +while ((dn = readdir(directory_node)) != NULL) { +char *fpath; +FILE *fd_sib; +size_t rd; +char *cr; + + +if (strncmp(dn->d_name, ts_fname, strlen(ts_fname))) +continue; + +asprintf(&fpath, "%s/%s", directory_path, dn->d_name); +fd_sib = fopen(fpath, "r"); +if (fd_sib == NULL) { +fprintf(stderr, "Unable to open file %s: %s\n", fpath, strerror(errno)); +continue; +} + + +rd = fread(buf, 1, sizeof(buf), fd_sib); +if (rd == sizeof(buf)) +fprintf(stderr, "%s:fread: probable overflow\n", __FILE__); +fclose(fd_sib); +free(fpath); + +/* + * chop off \n. + * Note: We consider that only one \n is present + * at the end of the file. + */ +cr = strchr(buf, '\n'); +if(cr) +*cr = '\0'; + +xml_entry(xs, ts_fname, buf); +} +xml_end_tag(xs); /* topology */ +xml_end_tag(xs); /* de->d_name */; +closedir(directory_node); +} +closedir(directory_parent); +xml_end_tag(xs); /* cpu */ + +xml_end_tag(xs); /* system */ +xml_end_tag(xs); /* devices */ +xml_end_tag(xs); /* sys */ +} + +/* + Generic function to write a start or selfclosing tag into an xml stream: + * + * or + * + * or + * + * or + * + * + * xs: xml stream to write to + * flags: + *XML_TAG_SC: self-close tag (no indentation increase and no end_tag) + *XML_TAG_CR: carriage return after markup + * tagname: xml markup name + * attr_fmt, ...: printf style argument for attributes + *no attribute if attr_fmt==NULL or attr_fmt is an empty string + */ +void xml_tag(xml_stream_t *xs, unsigned int flags, char *tagname, char *attr_fmt, ...) +{ +va_list ap; +int i; + +if (!(flags & XML_TAG_SC)) { +/* Not self-close tag */ +if (xs->indent_level == xs->stack_size) { +/* Stack overflow -> double size */ +xs->stack_size *= 2; +xs->stack = realloc (xs->stack, sizeof(xml_stack_tag_t) * xs->stack_size); +if (xs->stack == NULL) { +perror("xml_stream_init:realloc"); +free(xs); +return; +} +} +/* Remember tag */ +strcpy(xs->stack[xs->indent_level].tagname, tagname); +} + + +for (i = 0; i < xs->indent_level; i++) +fprintf(xs->fd,"\t"); + +fprintf(xs->fd, "<%s", tagname); +if (attr_fmt && strcmp(attr_fmt, "")) { +/* Tag has attribute */ +fprintf(xs->fd, " "); +va_start(ap, attr_fmt); +vfprintf(xs->fd, attr_fmt, ap); +va_end(ap); +} + +if (flags & XML_TAG_SC) +fprintf(xs->fd, "/>"); +else { +fprintf(xs->fd, ">"); +xs->indent_level++; +} + +if (flags & XML_TAG_NOCR) +return; + +fprintf(xs->fd, "\n"); +} + +/* + * Write an end tag into an xml stream: + * + * + * xs: xml stream to write to + * flags: + *XML_TAG_NOIND: do not indent tag + */ +void xml_end(xml_stream_t *xs, unsigned int flags) +{ +int i; + +xs->indent_level--; + +if (!(flags & XML_TAG_NOIND)) +for (i = 0; i < xs->indent_level; i++) +fprintf(xs->fd,"\t"); + +fprintf(xs->fd, "\n", xs->stack[xs->indent_level].tagname); + +} + +/* + * Write data to xml stream + * + * xs: xml stream to write to + * fmt, ...: printf style formatting + */ +void xml_content(xml_stream_t *xs, char *fmt, ...) +{ +va_list ap; + +va_start(ap, fmt); +vfprintf(xs->fd, fmt, ap); +va_end(ap); +} + +/* + * Create XML stream file and initialize headers. + * testname: name of the test + * root_tag: tag of root element + * title: title of the XML stream + * + * return: xml_stream_t pointer to be reused by subsequent xml_... calls. + */ +xml_stream_t * xml_stream_init(char *testname, char *root_tag, char *title) +{ +FILE *fd; +struct utsname u; +char *xmlfile; +xml_stream_t *xs; +time_t t; +struct tm *tmp; +char start_time[20]; + +xs = malloc (sizeof(xml_stream_t)); +if (xs == NULL) { +perror("xml_stream_init:malloc"); +return NULL; +} + +xs->stack = malloc (sizeof(xml_stack_tag_t) * TAG_STACK_INIT_SIZE); +if (xs->stack == NULL) { +perror("xml_stream_init:malloc2"); +free(xs); +return NULL; +} + +xs->stack_size = TAG_STACK_INIT_SIZE; + + +t = time(NULL); +tmp = localtime(&t); +if (tmp == NULL) { +perror("localtime"); +exit(EXIT_FAILURE); +} + +if (strftime(start_time, sizeof(start_time), "%Y-%m-%d.%H-%M-%S", tmp) == 0) { +fprintf(stderr, "strftime returned 0"); +exit(EXIT_FAILURE); +} + +xs->indent_level = 0; + + +if (-1 == asprintf(&xmlfile, "%s.%s.xml", testname, start_time)) { +fprintf(stderr, "xml_stream_init: Failed to allocate string for data filename\n"); +return NULL; +} + +/* generate the data file */ +if (!(fd = fopen(xmlfile, "w"))) +return NULL; + +xs->fd = fd; + +uname(&u); + +fprintf(xs->fd, "\n"); + +xml_start_tag(xs, root_tag); + +/* Headers */ +xml_entry(xs, "title", title); +xml_entry(xs, "testname", testname); +xml_entry(xs, "start-time", start_time); +xml_start_tag(xs, "systeminfo"); +xml_start_tag(xs, "uname"); +xml_entry(xs, "sysname", u.sysname); +xml_entry(xs, "nodename", u.nodename); +xml_entry(xs, "release", u.release); +xml_entry(xs, "version", u.version); +xml_entry(xs, "machine", u.machine); +xml_end_tag(xs); /* uname */ +xml_get_cpu_topology(xs); +xml_entry(xs, "free-user-id", xml_free_user_id); +xml_entry(xs, "online-cpus", "%ld", sysconf(_SC_NPROCESSORS_ONLN)); +xml_end_tag(xs); /* systeminfo */ +xml_entry(xs, "filename", xmlfile); + +return xs; +} + +/* + * Close XML stream. + * root_tag: tag of root element + * + */ +void xml_stream_close(xml_stream_t *xs) +{ +xml_end_tag(xs); /* root_tag */ +fclose(xs->fd); +free(xs->stack); +free(xs); +return; +} +

[PATCH 2/4] [RT][RFC][Take#5] Integration of xml into stats.

Gilles Carry — 2008-12-01T15:10:36

This patch adds a new function into libstat: xml_stats_container_save which handles an xml_stream_t instead of a file. It dumps the same data stats_container_save with XML format. Also added two fields to stats: timestamp and cpuid. Compilation is conditional to LIB_XML. --- testcases/realtime/include/libstats.h | 16 ++++++++++++ testcases/realtime/lib/libstats.c | 42 +++++++++++++++++++++++++++++++++ 2 files changed, 58 insertions(+), 0 deletions(-) diff --git a/testcases/realtime/include/libstats.h b/testcases/realtime/include/libstats.h index 05c26d8..fefad7b 100644 --- a/testcases/realtime/include/libstats.h +++ b/testcases/realtime/include/libstats.h < at >< at > -45,6 +45,10 < at >< at > #include #include #include +#include +#ifdef LIB_XML +#include +#endif #define MIN(A,B) ((A)<(B)?(A):(B)) #define MAX(A,B) ((A)>(B)?(A):(B)) < at >< at > -52,6 +56,8 < at >< at > typedef struct stats_record { long x; long y; +nsec_t timestamp; +int cpuid; } stats_record_t; typedef struct stats_container { < at >< at > -162,4 +168,14 < at >< at > void stats_hist_print(stats_container_t *hist); */ int stats_container_save(char *filename, char *title, char *labelx, char *labely, stats_container_t *data, char *mode); +#ifdef LIB_XML +/* stats_container_xml_save - save the x,y data to an xml file. + * xs: the stream previously created with xml_stream_init. + * labelx: the x-axis label + * labely: the y-axis label + * mode: "points" "lines" "steps" etc, see gnuplot help for plotting types + */ +int xml_stats_container_save(xml_stream_t *xs, char *title, char *xlabel, char *ylabel, stats_container_t *data, char *mode); +#endif + #endif /* LIBSTAT_H */ diff --git a/testcases/realtime/lib/libstats.c b/testcases/realtime/lib/libstats.c index 29e7ea7..fccf733 100644 --- a/testcases/realtime/lib/libstats.c +++ b/testcases/realtime/lib/libstats.c < at >< at > -43,6 +43,9 < at >< at > #include #include #include +#ifdef LIB_XML +#include +#endif int save_stats = 0; < at >< at > -355,3 +358,42 < at >< at > int stats_container_save(char *filename, char *title, char *xlabel, char *ylabel return 0; } + +#ifdef LIB_XML +int xml_stats_container_save(xml_stream_t *xs, char *title, char *xlabel, char *ylabel, stats_container_t *data, char *mode) +{ +int i; +long minx = 0, maxx = 0, miny = 0, maxy = 0; +stats_record_t *rec; + +xml_start_tag(xs, "stats"); +minx = maxx = data->records[0].x; +miny = maxy = data->records[0].y; +xml_entry(xs, "title",title); +xml_entry(xs, "xlabel",xlabel); +xml_entry(xs, "ylabel",ylabel); +xml_entry(xs, "mode",mode); +xml_start_tag(xs, "data"); + +for (i = 0; i < data->size; i++) { +rec = &data->records[i]; +minx = MIN(minx, rec->x); +maxx = MAX(maxx, rec->x); +miny = MIN(miny, rec->y); +maxy = MAX(maxy, rec->y); + +/* Self-closing tag with attributes: */ + xml_tag(xs, XML_TAG_SC, "e", "r=\"%d\" x=\"%ld\" y=\"%d\" t=\"%lld\" c=\"%d\"", i, rec->x, rec->y, rec->timestamp, rec->cpuid); +} + +xml_end_tag(xs); /* data */ +xml_entry(xs, "sample-size", "%ld", data->size); +xml_entry(xs, "minx", "%ld", minx); +xml_entry(xs, "maxx", "%ld", maxx); +xml_entry(xs, "miny", "%ld", miny); +xml_entry(xs, "maxy", "%ld", maxy); +xml_end_tag(xs); /* stats */ + +return 0; +} +#endif

[PATCH 3/4] [RT][RFC][Take#5] matrix_mult.c: add xml dump ofstatistics and results.

Gilles Carry — 2008-12-01T15:10:37

This simply adds xml function calls to allow the dumping of results and samples into an xml file. Compilation is conditional to LIB_XML. Signed-off-by: Gilles Carry public.gmane.org> --- testcases/realtime/func/matrix_mult/matrix_mult.c | 68 +++++++++++++++++++- 1 files changed, 64 insertions(+), 4 deletions(-) diff --git a/testcases/realtime/func/matrix_mult/matrix_mult.c b/testcases/realtime/func/matrix_mult/matrix_mult.c index e27f47d..f336ac8 100644 --- a/testcases/realtime/func/matrix_mult/matrix_mult.c +++ b/testcases/realtime/func/matrix_mult/matrix_mult.c < at >< at > -43,6 +43,9 < at >< at > #include #include #include +#ifdef LIB_XML +#include +#endif #define MAX_CPUS8192 #define PRIO43 < at >< at > -137,7 +140,7 < at >< at > void matrix_mult(int m_size) } } -void matrix_mult_record(int m_size, int index) +void matrix_mult_record(int m_size, int index, int cpuid) { nsec_t start, end, delta; int i; < at >< at > -149,6 +152,8 < at >< at > void matrix_mult_record(int m_size, int index) delta = (long)((end - start)/NS_PER_US); curdat->records[index].x = index; curdat->records[index].y = delta; +curdat->records[index].timestamp = start; +curdat->records[index].cpuid = cpuid; } int set_affinity(void) < at >< at > -189,7 +194,7 < at >< at > void *concurrent_thread(void *thread) index = iterations_percpu * thread_id; /* To avoid stats overlapping */ pthread_barrier_wait(&mult_start); for (i=0; i < iterations_percpu; i++) -matrix_mult_record(MATRIX_SIZE, index++); +matrix_mult_record(MATRIX_SIZE, index++, cpuid); return NULL; } < at >< at > -232,7 +237,7 < at >< at > void main_thread(void) printf("\nRunning sequential operations\n"); start = rt_gettime(); for (i = 0; i < iterations; i++) -matrix_mult_record(MATRIX_SIZE, i); +matrix_mult_record(MATRIX_SIZE, i, cpuid); end = rt_gettime(); delta = (long)((end - start)/NS_PER_US); < at >< at > -310,6 +315,58 < at >< at > void main_thread(void) criteria); printf("Result: %s\n", ret ? "FAIL" : "PASS"); +#ifdef LIB_XML +if (! xml_dump) +return; + +{ +xml_stream_t *xs; + +/* XML dump */ +xs = xml_stream_init("matrix_mult", "ltp-run", "matrix-mult"); +if (!xs) { +fprintf(stderr, "Warning: could not save results as xml\n"); +return; +} +xml_entry(xs, "title", "Matrix Multiplication (SMP Performance)"); +xml_start_tag(xs, "parameters"); +xml_entry(xs, "iterations", "%ld", iterations); +xml_entry(xs, "calc-per-iter", "%ld", ops); +xml_end_tag(xs); /* parameters */ + +xml_start_tag(xs, "sequential"); +xml_entry(xs, "min", "%ld",smin); +xml_entry(xs, "max", "%ld",smax); +xml_entry(xs, "avg", "%.4f",savg); +xml_entry(xs, "stddev", "%.4f",stats_stddev(&sdat)); + +xml_stats_container_save(xs, "data", +"Iteration", "Runtime (us)", &sdat, "points"); +xml_stats_container_save(xs, "histogram", +"Runtime (us)", "Samples", &shist, "steps"); +xml_end_tag(xs); /* sequential */ + +xml_start_tag(xs, "concurrent"); +xml_entry(xs, "min", "%ld",cmin); +xml_entry(xs, "max", "%ld",cmax); +xml_entry(xs, "avg", "%.4f",cavg); +xml_entry(xs, "stddev", "%.4f",stats_stddev(&cdat)); + +xml_stats_container_save(xs, "data", +"Iteration", "Runtime (us)", &cdat, "points"); +xml_stats_container_save(xs, "histogram", +"Runtime (us)", "Samples", &chist, "steps"); +xml_end_tag(xs); /* concurrent */ + +xml_start_tag(xs, "ratio"); +xml_entry(xs, "min", "%.4f",(float)smin/cmin); +xml_entry(xs, "max", "%.4f",(float)smax/cmax); +xml_entry(xs, "avg", "%.4f",(float)savg/cavg); +xml_end_tag(xs); /* ratio */ +xml_stream_close(xs); /* ltp-run */ +} +#endif + return; } < at >< at > -317,7 +374,10 < at >< at > int main(int argc, char *argv[]) { setup(); pass_criteria = PASS_CRITERIA; -rt_init("jl:i:h", parse_args, argc, argv); +if (rt_init("jl:i:h", parse_args, argc, argv)) { +usage(); +exit(1); +} numcpus = sysconf(_SC_NPROCESSORS_ONLN); /* the minimum avg concurrent multiplier to pass */ criteria = pass_criteria * numcpus;

[PATCH 4/4] [RT][RFC][Take#5] Documentation and tools for XMLlibrary

Gilles Carry — 2008-12-01T15:10:38

Documentation: just the basics on how to - run - code - compile Tooles: - xml_collect.sh Also an example of XML dump. Signed-off-by: Gilles Carry public.gmane.org> --- testcases/realtime/doc/XML | 261 ++++++++++++++++++++++++++++ testcases/realtime/scripts/xml_collect.xml | 15 ++ 2 files changed, 276 insertions(+), 0 deletions(-) create mode 100644 testcases/realtime/doc/XML create mode 100755 testcases/realtime/scripts/xml_collect.xml diff --git a/testcases/realtime/doc/XML b/testcases/realtime/doc/XML new file mode 100644 index 0000000..cd886e3 --- /dev/null +++ b/testcases/realtime/doc/XML < at >< at > -0,0 +1,261 < at >< at > +XML library +=========== + +1. Why dump results and stats with XML? +--------------------------------------- + +RT tests already generate stats and plot files. What XML can give more? + +Post processing: +XML provides an easy way to transform the data without the need to change and +recompile the test. Just create or modify an Xquery to get the requested output. + +Regression/comparison/correlation: +With XML data, it's easy to gather several tests outputs and see what changed +from one test to another. +Plotting combined graphic can be made very easy using the proper Xquery. + + +2. Run test with XML +-------------------- + +Usage: +Run test with -x option. +Example: +mtrix_mult -x my-kernel-setting-1.1 + +For each run, an XML dump file is created. +The file is names ..xml + +Note: +This library does not offer any post-processing tool. + + +3. Develop with libxml +---------------------- + +Synopsis: +xml_stream_t *xs; + +rt_init(option_string, parse_args, argc, argv); +... +xs = xml_stream_init("foo", "ltp-run", "foo test"); + + +/* Begin of application XML dump. */ +/* Use according to taste. */ +xml_start_tag (xs, "this-node"); +... +xml_start_tag (xs, "other-node"); +... +xml_end_tag (xs); /* other-node */ +... +xml_end_tag (xs); /* this-node */ +... +xml_entry (xs, "data", "%s %ld", mystring, mylong); +... +xml_empty_tag (xs, "empty-node"); +... +/* End of application XML dump. */ + +xml_stream_close(xs); + + +Note: +rt_init must be called before xml_stream_init as the former sets global +variables used by xml_stream_init in order to setup headers in XML +document. + + +Warning: +This library does not perform any check: document well-formed and +grammar are programmer's responsibility. + + +Compilation: +To build tests with libxml run: +LIB_XML=1 make + + +Adding XML dump to your test: +Make XML conditional: use #ifdef LIB_XML to include specific code. + +To initialize the XML stream: +xs = xml_stream_init("myXMLfile", "myRootTag", "The test title here"); + +This creates a new XML document by opening a file descriptor and adding +all proper headers (using global variables set by rt_init: +xml_free_user_id). + +The generic function to write xml tag is: void xml_tag. +See include/libxml.h for a full definition of functions and macros. + +To write a node start tag to XML document: +xml_start_tag (xs, "mynode"); + +To write a node end tag to XML document: +xml_end_tag (xs); + +To write data enclosed by tags anystring to XML document: +xml_entry (xs, "mytag", "printf style format", args...); + +To terminate the XML stream: +xml_stream_close(xs); + + +XML document header: +Basically, this is to compare test runs performed on differents +architectures/kernels/configurations and spot regressions. +Hence, it is vital to identify the conditions in which the test was +run. This library automatically adds information to allow this +identification. + +In the header we can find the following elements: +: +<start-time>: +<systeminfo>: +Though it is not possible to completely identify what's in the +box/kernel, this compound element gives an overall view of the +architecure. +Subelements descritpion: +<uname>: report data as 'uname -a' +<free-user-id>: a free field set by user to tell what's the +difference between the here-used kernel (probably hacked) and +the original version reported by uname. +This is set by the -x arg in the command line. +<online-cpus>: obvious +<sys>: a structure of tags that imitate /sys filesystem, though +only featuring the useful information that describe the system's +topology: how many cpu nodes/cores/threads. +As an example, two system featuring each 8 online cpus may +offer very different performances in thread parallelization. +Looking at <systeminfo> gives the answer as one is a +4-dualthread-cpu box while the other is an 8-unthreaded-cpu box. + + +XML document application dump: +Application (the test itself) should not only dump results and samples +but also information about the condition in which the test has been run. +In the example below: +<parameters> +<iterations> +<calc-per-iter> + + +4. Example of generated XML +--------------------------- + +<?xml version="1.0" encoding="UTF-8"?> +<ltp-run> + <title>matrix-mult + 2008-10-23.10-06-43 + + + Linux + excalibur + 2.6.26.6-rt11 + #146 SMP PREEMPT RT Tue Oct 14 09:15:00 CEST 2008 + ppc64 + + + + + + + + + + + + + + + + + + + + + + 0-1 + + + + + 0-1 + + + + + 2-3 + + + + + 2-3 + + + + + 4-5 + + + + + 4-5 + + + + + 6-7 + + + + + 6-7 + + + + + + + special-hack-v2 + 8 + + matrix_mult + Matrix Multiplication (SMP Performance) + + + + 128 + 8 + + ...snip... + + + + +5. Post processing +------------------ + +Of course, anyone is free to use whatever tool he wants to postprocess the generated data. + +I used Saxonica's XQuery (saxon) to do the job. +Since I'm not an XML expert I shall only explain the way I did my postprocessing. + +Once the test is finished, use the script xml_collect.sh to create file collection.xml that references all *.xml files in the current directory. This must be done every time you generate new xml outputs. + + +Here is an example of xquery script I used for matrix_mult stat extract: + +for $s in collection("collection.xml")//ltp-run[testname="matrix_mult"] +let $min := min($s/concurrent/stats[title="data"]/data/e/t) +where $s/systeminfo/free-user-id = "newcomb" +return +for $e in $s/concurrent/stats[title="data"]/data/e +order by $e/< at >t +return ( +(data($e/< at >t) - $min) div 1e8 ," ",data($e/< at >y)," +" +) + diff --git a/testcases/realtime/scripts/xml_collect.xml b/testcases/realtime/scripts/xml_collect.xml new file mode 100755 index 0000000..96c2809 --- /dev/null +++ b/testcases/realtime/scripts/xml_collect.xml < at >< at > -0,0 +1,15 < at >< at > +#!/bin/sh + +COLL=collection.xml +COLL_TMP=$COLL.tmp +rm -f $COLL $COLL_TMP + +echo > $COLL_TMP "" +ls -1 *.xml | while read file +do +[ "$file" == $COLL ] && continue +echo >> $COLL_TMP "" +done +echo >> $COLL_TMP "" + +mv $COLL_TMP $COLL

[PATCH 0/4][RT][RFC][Take#5] XML dumps for realtime tests

Gilles Carry — 2008-12-01T15:10:34

Hello, To overcome libstats limitations, I have implemented this library and integrated it into libstats matrix_mult.c I've used this because I had to compare/correlate stats of differents tests runs on several kernels and architectures. This proved very useful as once the tests have run, many extracts can be done from original results, without having to modify/recompile/rerun the test itself. This really made things easier. With a single test run output, I could plot 2-D or 3-D graphs just by changing the xquery that generates the gnuplot data file. Basic understanding of XML is necessary to use this. I think this work is worth sharing. I wish people review it and comment it. Though it's been implemented on top of realtime tests, it should be easily portable to the reset of LTP, should some be interested... This series consists of four patches: first is the library itself, second is the integration with libstat, third is a first use with matrix_mult, forth is the documentation and a tool. ------------------------------------------------------------------------- This SF.Net email is sponsored by the Moblin Your Move Developer's challenge Build the coolest Linux based applications with Moblin SDK & win great prizes Grand prize is a trip for two to an Open Source event anywhere in the world http://moblin-contest.org/redirect.php?banner_id=100&url=/