git.sesse.net Git - vlc/blob - modules/misc/testsuite/test4.c

   1 /*****************************************************************************
   2  * test4.c : Miscellaneous stress tests module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2002 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Samuel Hocevar <sam@zoy.org>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 #ifdef HAVE_CONFIG_H
  28 # include "config.h"
  29 #endif
  30
  31 #include <vlc/vlc.h>
  32
  33 #include <signal.h>
  34
  35 /*****************************************************************************
  36  * Defines
  37  *****************************************************************************/
  38 #define MAXVAR        50                    /* Number of variables to create */
  39 #define MAXSET      2000                       /* Number of variables to set */
  40 #define MAXOBJ      1000                      /* Number of objects to create */
  41 #define MAXLOOK    10000                      /* Number of objects to lookup */
  42 #define MAXTH          4                       /* Number of threads to spawn */
  43
  44 /*****************************************************************************
  45  * Local prototypes.
  46  *****************************************************************************/
  47 static int    Foo       ( vlc_object_t *, char const *,
  48                           vlc_value_t, vlc_value_t, void * );
  49 static int    Callback  ( vlc_object_t *, char const *,
  50                           vlc_value_t, vlc_value_t, void * );
  51 static int    MyCallback( vlc_object_t *, char const *,
  52                           vlc_value_t, vlc_value_t, void * );
  53 static void * MyThread  ( vlc_object_t * );
  54
  55 static int    Stress    ( vlc_object_t *, char const *,
  56                           vlc_value_t, vlc_value_t, void * );
  57 static void * Dummy     ( vlc_object_t * );
  58
  59 static int    Signal    ( vlc_object_t *, char const *,
  60                           vlc_value_t, vlc_value_t, void * );
  61
  62 /*****************************************************************************
  63  * Module descriptor.
  64  *****************************************************************************/
  65 vlc_module_begin();
  66     set_description( _("Miscellaneous stress tests") );
  67     var_Create( p_module->p_libvlc, "foo-test",
  68                 VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  69     var_AddCallback( p_module->p_libvlc, "foo-test", Foo, NULL );
  70     var_Create( p_module->p_libvlc, "callback-test",
  71                 VLC_VAR_VOID | VLC_VAR_ISCOMMAND );
  72     var_AddCallback( p_module->p_libvlc, "callback-test", Callback, NULL );
  73     var_Create( p_module->p_libvlc, "stress-test",
  74                 VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  75     var_AddCallback( p_module->p_libvlc, "stress-test", Stress, NULL );
  76     var_Create( p_module->p_libvlc, "signal",
  77                 VLC_VAR_STRING | VLC_VAR_ISCOMMAND );
  78     var_AddCallback( p_module->p_libvlc, "signal", Signal, NULL );
  79 vlc_module_end();
  80
  81 /*****************************************************************************
  82  * Foo: put anything here
  83  *****************************************************************************/
  84 static int Foo( vlc_object_t *p_this, char const *psz_cmd,
  85                 vlc_value_t oldval, vlc_value_t newval, void *p_data )
  86 {
  87     vlc_value_t val;
  88     int i;
  89
  90     var_Create( p_this, "honk", VLC_VAR_STRING | VLC_VAR_HASCHOICE );
  91
  92     val.psz_string = "foo";
  93     var_Change( p_this, "honk", VLC_VAR_ADDCHOICE, &val, NULL );
  94     val.psz_string = "bar";
  95     var_Change( p_this, "honk", VLC_VAR_ADDCHOICE, &val, NULL );
  96     val.psz_string = "baz";
  97     var_Change( p_this, "honk", VLC_VAR_ADDCHOICE, &val, NULL );
  98     var_Change( p_this, "honk", VLC_VAR_SETDEFAULT, &val, NULL );
  99
 100     var_Get( p_this, "honk", &val ); printf( "value: %s\n", val.psz_string );
 101
 102     val.psz_string = "foo";
 103     var_Set( p_this, "honk", val );
 104
 105     var_Get( p_this, "honk", &val ); printf( "value: %s\n", val.psz_string );
 106
 107     val.psz_string = "blork";
 108     var_Set( p_this, "honk", val );
 109
 110     var_Get( p_this, "honk", &val ); printf( "value: %s\n", val.psz_string );
 111
 112     val.psz_string = "baz";
 113     var_Change( p_this, "honk", VLC_VAR_DELCHOICE, &val, NULL );
 114
 115     var_Get( p_this, "honk", &val ); printf( "value: %s\n", val.psz_string );
 116
 117     var_Change( p_this, "honk", VLC_VAR_GETLIST, &val, NULL );
 118     for( i = 0 ; i < val.p_list->i_count ; i++ )
 119     {
 120         printf( "value %i: %s\n", i, val.p_list->p_values[i].psz_string );
 121     }
 122     var_Change( p_this, "honk", VLC_VAR_FREELIST, &val, NULL );
 123
 124     var_Destroy( p_this, "honk" );
 125
 126     return VLC_SUCCESS;
 127 }
 128
 129 /*****************************************************************************
 130  * Callback: test callback functions
 131  *****************************************************************************/
 132 static int Callback( vlc_object_t *p_this, char const *psz_cmd,
 133                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
 134 {
 135     int i;
 136     char psz_var[20];
 137     vlc_object_t *pp_objects[10];
 138     vlc_value_t val;
 139
 140     /* Allocate a few variables */
 141     for( i = 0; i < 1000; i++ )
 142     {
 143         sprintf( psz_var, "blork-%i", i );
 144         var_Create( p_this, psz_var, VLC_VAR_INTEGER );
 145         var_AddCallback( p_this, psz_var, MyCallback, NULL );
 146     }
 147
 148     /*
 149      *  Test #1: callback loop detection
 150      */
 151     printf( "Test #1: callback loop detection\n" );
 152
 153     printf( " - without boundary check (vlc should print an error)\n" );
 154     val.i_int = 1234567;
 155     var_Set( p_this, "blork-12", val );
 156
 157     printf( " - with boundary check\n" );
 158     val.i_int = 12;
 159     var_Set( p_this, "blork-12", val );
 160
 161     /*
 162      *  Test #2: concurrent access
 163      */
 164     printf( "Test #2: concurrent access\n" );
 165
 166     printf( " - launch worker threads\n" );
 167
 168     for( i = 0; i < 10; i++ )
 169     {
 170         pp_objects[i] = vlc_object_create( p_this, VLC_OBJECT_GENERIC );
 171         vlc_object_attach( pp_objects[i], p_this );
 172         vlc_thread_create( pp_objects[i], "foo", MyThread, 0, true );
 173     }
 174
 175     msleep( 3000000 );
 176
 177     printf( " - kill worker threads\n" );
 178
 179     for( i = 0; i < 10; i++ )
 180     {
 181         vlc_object_kill( pp_objects[i] );
 182         vlc_thread_join( pp_objects[i] );
 183         vlc_object_detach( pp_objects[i] );
 184         vlc_object_release( pp_objects[i] );
 185     }
 186
 187     /* Clean our mess */
 188     for( i = 0; i < 1000; i++ )
 189     {
 190         sprintf( psz_var, "blork-%i", i );
 191         var_DelCallback( p_this, psz_var, MyCallback, NULL );
 192         var_Destroy( p_this, psz_var );
 193     }
 194
 195     return VLC_SUCCESS;
 196 }
 197
 198 /*****************************************************************************
 199  * MyCallback: used by callback-test
 200  *****************************************************************************/
 201 static int MyCallback( vlc_object_t *p_this, char const *psz_var,
 202                        vlc_value_t oldval, vlc_value_t newval, void *p_data )
 203 {
 204     int i_var = 1 + atoi( psz_var + strlen("blork-") );
 205     char psz_newvar[20];
 206
 207     if( i_var == 1000 )
 208     {
 209         i_var = 0;
 210     }
 211
 212     /* If we are requested to stop, then stop. */
 213     if( i_var == newval.i_int )
 214     {
 215         return VLC_SUCCESS;
 216     }
 217
 218     /* If we're the blork-3 callback, set blork-4, and so on. */
 219     sprintf( psz_newvar, "blork-%i", i_var );
 220     var_Set( p_this, psz_newvar, newval );
 221
 222     return VLC_SUCCESS;
 223 }
 224
 225 /*****************************************************************************
 226  * MyThread: used by callback-test, creates objects and then do nothing.
 227  *****************************************************************************/
 228 static void * MyThread( vlc_object_t *p_this )
 229 {
 230     char psz_var[20];
 231     vlc_value_t val;
 232     vlc_object_t *p_parent = p_this->p_parent;
 233
 234     vlc_thread_ready( p_this );
 235
 236     val.i_int = 42;
 237
 238     while( !p_this->b_die )
 239     {
 240         int i = (int) (100.0 * rand() / (RAND_MAX));
 241
 242         sprintf( psz_var, "blork-%i", i );
 243         val.i_int = i + 200;
 244         var_Set( p_parent, psz_var, val );
 245
 246         /* This is quite heavy, but we only have 10 threads. Keep cool. */
 247         msleep( 1000 );
 248     }
 249
 250     return NULL;
 251 }
 252
 253 /*****************************************************************************
 254  * Stress: perform various stress tests
 255  *****************************************************************************/
 256 static int Stress( vlc_object_t *p_this, char const *psz_cmd,
 257                    vlc_value_t oldval, vlc_value_t newval, void *p_data )
 258 {
 259     vlc_object_t **pp_objects;
 260     mtime_t start;
 261     char ** ppsz_name;
 262     char *  psz_blob;
 263     int     i, i_level;
 264
 265     if( *newval.psz_string )
 266     {
 267         i_level = atoi( newval.psz_string );
 268         if( i_level <= 0 )
 269         {
 270             i_level = 1;
 271         }
 272         else if( i_level > 200 )
 273         {
 274             /* It becomes quite dangerous above 150 */
 275             i_level = 200;
 276         }
 277     }
 278     else
 279     {
 280         i_level = 10;
 281     }
 282
 283     /* Allocate required data */
 284     ppsz_name = malloc( MAXVAR * i_level * sizeof(char*) );
 285     psz_blob = malloc( 20 * MAXVAR * i_level * sizeof(char) );
 286     for( i = 0; i < MAXVAR * i_level; i++ )
 287     {
 288         ppsz_name[i] = psz_blob + 20 * i;
 289     }
 290
 291     pp_objects = malloc( MAXOBJ * i_level * sizeof(void*) );
 292
 293     /*
 294      *  Test #1: objects
 295      */
 296     printf( "Test #1: objects\n" );
 297
 298     printf( " - creating %i objects\n", MAXOBJ * i_level );
 299     start = mdate();
 300     for( i = 0; i < MAXOBJ * i_level; i++ )
 301     {
 302         pp_objects[i] = vlc_object_create( p_this, VLC_OBJECT_GENERIC );
 303     }
 304
 305     printf( " - randomly looking up %i objects\n", MAXLOOK * i_level );
 306     for( i = MAXLOOK * i_level; i--; )
 307     {
 308         int id = (int) (MAXOBJ * i_level * 1.0 * rand() / (RAND_MAX));
 309         vlc_object_get( pp_objects[id]->i_object_id );
 310         vlc_object_release( p_this );
 311     }
 312
 313     printf( " - destroying the objects (LIFO)\n" );
 314     for( i = MAXOBJ * i_level; i--; )
 315     {
 316         vlc_object_release( pp_objects[i] );
 317     }
 318
 319     printf( "done (%fs).\n", (mdate() - start) / 1000000.0 );
 320
 321     /*
 322      *  Test #2: integer variables
 323      */
 324     printf( "Test #2: integer variables\n" );
 325
 326     printf( " - creating %i integer variables\n", MAXVAR * i_level );
 327     start = mdate();
 328     for( i = 0; i < MAXVAR * i_level; i++ )
 329     {
 330         sprintf( ppsz_name[i], "foo-%04i-bar-%04x", i, i * 11 );
 331         var_Create( p_this, ppsz_name[i], VLC_VAR_INTEGER );
 332     }
 333
 334     printf( " - randomly assigning %i values\n", MAXSET * i_level );
 335     for( i = 0; i < MAXSET * i_level; i++ )
 336     {
 337         int v = (int) (MAXVAR * i_level * 1.0 * rand() / (RAND_MAX));
 338         var_Set( p_this, ppsz_name[v], (vlc_value_t)i );
 339     }
 340
 341     printf( " - destroying the variables\n" );
 342     for( i = 0; i < MAXVAR * i_level; i++ )
 343     {
 344         var_Destroy( p_this, ppsz_name[i] );
 345     }
 346
 347     printf( "done (%fs).\n", (mdate() - start) / 1000000.0 );
 348
 349     /*
 350      *  Test #3: string variables
 351      */
 352     printf( "Test #3: string variables\n" );
 353
 354     printf( " - creating %i string variables\n", MAXVAR * i_level );
 355     start = mdate();
 356     for( i = 0; i < MAXVAR * i_level; i++ )
 357     {
 358         sprintf( ppsz_name[i], "foo-%04i-bar-%04x", i, i * 11 );
 359         var_Create( p_this, ppsz_name[i], VLC_VAR_STRING );
 360     }
 361
 362     printf( " - randomly assigning %i values\n", MAXSET * i_level );
 363     for( i = 0; i < MAXSET * i_level; i++ )
 364     {
 365         int v = (int) (MAXVAR * i_level * 1.0 * rand() / (RAND_MAX));
 366         var_Set( p_this, ppsz_name[v], (vlc_value_t)ppsz_name[v] );
 367     }
 368
 369     printf( " - destroying the variables\n" );
 370     for( i = 0; i < MAXVAR * i_level; i++ )
 371     {
 372         var_Destroy( p_this, ppsz_name[i] );
 373     }
 374
 375     printf( "done (%fs).\n", (mdate() - start) / 1000000.0 );
 376
 377     /*
 378      *  Test #4: threads
 379      */
 380     printf( "Test #4: threads\n" );
 381     start = mdate();
 382
 383     printf( " - spawning %i threads that will each create %i objects\n",
 384             MAXTH * i_level, MAXOBJ/MAXTH );
 385     for( i = 0; i < MAXTH * i_level; i++ )
 386     {
 387         pp_objects[i] = vlc_object_create( p_this, VLC_OBJECT_GENERIC );
 388         vlc_thread_create( pp_objects[i], "foo", Dummy, 0, true );
 389     }
 390
 391     printf( " - killing the threads (LIFO)\n" );
 392     for( i = MAXTH * i_level; i--; )
 393     {
 394         pp_objects[i]->b_die = true;
 395         vlc_thread_join( pp_objects[i] );
 396         vlc_object_release( pp_objects[i] );
 397     }
 398
 399     printf( "done (%fs).\n", (mdate() - start) / 1000000.0 );
 400
 401     /* Free required data */
 402     free( pp_objects );
 403     free( psz_blob );
 404     free( ppsz_name );
 405
 406     return VLC_SUCCESS;
 407 }
 408
 409 /*****************************************************************************
 410  * Dummy: used by stress-test, creates objects and then do nothing.
 411  *****************************************************************************/
 412 static void * Dummy( vlc_object_t *p_this )
 413 {
 414     int i;
 415     vlc_object_t *pp_objects[MAXOBJ/MAXTH];
 416
 417     for( i = 0; i < MAXOBJ/MAXTH; i++ )
 418     {
 419         pp_objects[i] = vlc_object_create( p_this, VLC_OBJECT_GENERIC );
 420     }
 421
 422     vlc_thread_ready( p_this );
 423
 424     while( !p_this->b_die )
 425     {
 426         msleep( 10000 );
 427     }
 428
 429     for( i = MAXOBJ/MAXTH; i--; )
 430     {
 431         vlc_object_release( pp_objects[i] );
 432     }
 433
 434     return NULL;
 435 }
 436
 437 /*****************************************************************************
 438  * Signal: send a signal to the current thread.
 439  *****************************************************************************/
 440 static int Signal( vlc_object_t *p_this, char const *psz_cmd,
 441                    vlc_value_t oldval, vlc_value_t newval, void *p_data )
 442 {
 443     raise( atoi(newval.psz_string) );
 444     return VLC_SUCCESS;
 445 }