/* * @licence app begin@ * SPDX license identifier: MPL-2.0 * * Copyright (C) 2011-2015, BMW AG * * This file is part of GENIVI Project DLT - Diagnostic Log and Trace. * * This Source Code Form is subject to the terms of the * Mozilla Public License (MPL), v. 2.0. * If a copy of the MPL was not distributed with this file, * You can obtain one at http://mozilla.org/MPL/2.0/. * * For further information see http://www.genivi.org/. * @licence end@ */ /*! * \author Alexander Wenzel * * \copyright Copyright © 2011-2015 BMW AG. \n * License MPL-2.0: Mozilla Public License version 2.0 http://mozilla.org/MPL/2.0/. * * \file dlt-test-stress.c */ /******************************************************************************* ** ** ** SRC-MODULE: dlt-test-stress.c ** ** ** ** TARGET : linux ** ** ** ** PROJECT : DLT ** ** ** ** AUTHOR : Alexander Wenzel Alexander.AW.Wenzel@bmw.de ** ** Markus Klein ** ** ** ** PURPOSE : ** ** ** ** REMARKS : ** ** ** ** PLATFORM DEPENDANT [yes/no]: yes ** ** ** ** TO BE CHANGED BY USER [yes/no]: no ** ** ** *******************************************************************************/ /******************************************************************************* ** Author Identity ** ******************************************************************************** ** ** ** Initials Name Company ** ** -------- ------------------------- ---------------------------------- ** ** aw Alexander Wenzel BMW ** ** mk Markus Klein Fraunhofer ESK ** *******************************************************************************/ /******************************************************************************* ** Revision Control History ** *******************************************************************************/ /* * $LastChangedRevision: 1670 $ * $LastChangedDate: 2011-04-08 15:12:06 +0200 (Fr, 08. Apr 2011) $ * $LastChangedBy$ * Initials Date Comment * aw 13.01.2010 initial */ #include #include /* for isprint() */ #include #include /* for printf() and fprintf() */ #include /* for atoi() and exit() */ #include /* for memset() */ #include /* for close() */ #include /* POSIX Threads */ #include "dlt.h" #include "dlt_common.h" /* for dlt_get_version() */ DltContext mycontext[9999]; typedef struct { int num; } thread_data_t; #define STRESS1_NUM_CONTEXTS 3000 #define STRESS2_MAX_NUM_THREADS 64 #define STRESS3_MAX_NUM_MESSAGES 512 #define MAX_TESTS 3 void stress1(void); void stress2(void); void thread_function(void); void stress3(void); /* * This environment variable is used when developer wants to interrupt program manually */ char *env_manual_interruption = 0; /** * Print usage information of tool. */ void usage() { char version[255]; dlt_get_version(version, 255); printf("Usage: dlt-test-stress [options]\n"); printf("Test application executing several stress tests.\n"); printf("%s \n", version); printf("Options:\n"); printf(" -v Verbose mode\n"); printf(" -f filename Use local log file instead of sending to daemon\n"); printf(" -1 Execute test 1 (register/unregister many contexts)\n"); printf(" In order to interrupt test manually (e.g: wait for ENTER key),\n"); printf(" set environment variable DLT_TEST_MANUAL_INTERRUPTION=1\n"); printf(" -2 Execute test 2 (multiple threads logging data)\n"); printf(" -3 Execute test 3 (logging much data)\n"); } /** * Main function of tool. */ int main(int argc, char *argv[]) { /*int vflag = 0; */ char *fvalue = 0; int test[MAX_TESTS]; int i, c, help; for (i = 0; i < MAX_TESTS; i++) test[i] = 0; opterr = 0; while ((c = getopt (argc, argv, "vf:123")) != -1) switch (c) { case 'v': { /*vflag = 1; */ break; } case 'f': { fvalue = optarg; break; } case '1': { test[0] = 1; env_manual_interruption = getenv("DLT_TEST_MANUAL_INTERRUPTION"); break; } case '2': { test[1] = 1; break; } case '3': { test[2] = 1; break; } case '?': { if (optopt == 'f') fprintf (stderr, "Option -%c requires an argument.\n", optopt); else if (isprint (optopt)) fprintf (stderr, "Unknown option `-%c'.\n", optopt); else fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt); /* unknown or wrong option used, show usage information and terminate */ usage(); return -1; } default: { abort (); return -1;/*for parasoft */ } } if (fvalue) { /* DLT is intialised automatically, except another output target will be used */ if (dlt_init_file(fvalue) < 0) /* log to file */ return -1; } help = 0; for (i = 0; i < MAX_TESTS; i++) if (test[i] == 1) { help = 1; break; } if (help == 0) { usage(); return -1; } DLT_REGISTER_APP("DSTS", "DLT daemon stress tests"); if (test[0]) stress1(); if (test[1]) stress2(); if (test[2]) stress3(); DLT_UNREGISTER_APP(); sleep(1); return 0; } void stress1(void) { int i, c; char ctid[5]; struct timespec ts; printf("Starting stress test1...\n"); printf("* Register %d contexts...\n", STRESS1_NUM_CONTEXTS); for (i = 0; i < STRESS1_NUM_CONTEXTS; i++) { /* Generate id */ memset(ctid, 0, 5); snprintf(ctid, 5, "%d", i); /*printf("%i: '%s' \n",i,ctid); */ dlt_register_context(&(mycontext[i]), ctid, ctid); ts.tv_sec = 0; ts.tv_nsec = 500 * 1000; nanosleep(&ts, NULL); } if (env_manual_interruption && (strcmp(env_manual_interruption, "1") == 0)) { printf("press \"Enter\" to terminate test"); while (1) { c=getchar(); /* if "Return" is pressed, exit loop; */ if (c==10) { break; } } } printf("* Unregister %d contexts...\n", STRESS1_NUM_CONTEXTS); for (i = 0; i < STRESS1_NUM_CONTEXTS; i++) { DLT_UNREGISTER_CONTEXT(mycontext[i]); ts.tv_sec = 0; ts.tv_nsec = 500 * 1000; nanosleep(&ts, NULL); } printf("Finished stress test1 \n\n"); } void stress2(void) { int ret, index; struct timespec ts; pthread_t thread[STRESS2_MAX_NUM_THREADS]; thread_data_t thread_data[STRESS2_MAX_NUM_THREADS]; printf("Starting stress test2... \n"); srand(time(NULL)); printf("* Creating %d Threads, each of them registers one context,\n", STRESS2_MAX_NUM_THREADS); printf(" sending one log message, then unregisters the context\n"); for (index = 0; index < STRESS2_MAX_NUM_THREADS; index++) { thread_data[index].num = index; ret = pthread_create(&(thread[index]), NULL, (void *)&thread_function, (void *)&(thread_data[index])); if (ret != 0) printf("Error creating thread %d: %s \n", index, strerror(errno)); ts.tv_sec = 0; ts.tv_nsec = 1000 * 1000; nanosleep(&ts, NULL); } for (index = 0; index < STRESS2_MAX_NUM_THREADS; index++) pthread_join(thread[index], NULL); printf("Finished stress test2 \n\n"); } void thread_function(void) { /*thread_data_t *data; */ DLT_DECLARE_CONTEXT(context_thread1); char ctid[5]; struct timespec ts; /*data = (thread_data_t *) ptr; */ memset(ctid, 0, 5); /* Create random context id */ snprintf(ctid, 5, "%.2x", rand() & 0x0000ffff); ts.tv_sec = 0; ts.tv_nsec = rand(); nanosleep(&ts, NULL); DLT_REGISTER_CONTEXT(context_thread1, ctid, ctid); DLT_LOG(context_thread1, DLT_LOG_INFO, DLT_STRING(ctid)); DLT_UNREGISTER_CONTEXT(context_thread1); } void stress3(void) { DLT_DECLARE_CONTEXT(context_stress3); char buffer[STRESS3_MAX_NUM_MESSAGES]; int num; struct timespec ts; /* Performance test */ DLT_REGISTER_CONTEXT(context_stress3, "TST3", "Stress Test 3 - Performance"); printf("Starting stress test3... \n"); printf("* Logging raw data, up to a size of %d\n", STRESS3_MAX_NUM_MESSAGES); for (num = 0; num < STRESS3_MAX_NUM_MESSAGES; num++) { buffer[num] = num; DLT_LOG(context_stress3, DLT_LOG_INFO, DLT_INT(num), DLT_RAW(buffer, num)); ts.tv_sec = 0; ts.tv_nsec = 10000 * 1000; nanosleep(&ts, NULL); } printf("Finished stress test3 \n\n"); }