LCOV - code coverage report
Current view: top level - benchmarks - large.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 0 58 0.0 %
Date: 2019-09-12 12:28:41 Functions: 0 10 0.0 %

          Line data    Source code
       1             : /**
       2             :  * @file
       3             :  *
       4             :  * @brief
       5             :  *
       6             :  * @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
       7             :  */
       8             : 
       9             : #include <benchmarks.h>
      10             : 
      11             : KDB * kdb;
      12             : Key * key;
      13             : KeySet * large;
      14             : 
      15           0 : void benchmarkOpen (void)
      16             : {
      17           0 :         kdb = kdbOpen (key);
      18           0 : }
      19             : 
      20           0 : void benchmarkInread (void)
      21             : {
      22           0 :         KeySet * n = ksNew (0, KS_END);
      23           0 :         kdbGet (kdb, n, key);
      24           0 :         ksDel (n);
      25           0 : }
      26             : 
      27           0 : void benchmarkReadin (void)
      28             : {
      29           0 :         KeySet * n = ksNew (0, KS_END);
      30           0 :         kdbGet (kdb, n, key);
      31           0 :         ksDel (n);
      32           0 : }
      33             : 
      34           0 : void benchmarkLookupByName (void)
      35             : {
      36             :         int i, j;
      37             :         char name[KEY_NAME_LENGTH + 1];
      38             : 
      39           0 :         for (i = 0; i < NUM_DIR; i++)
      40             :         {
      41           0 :                 snprintf (name, KEY_NAME_LENGTH, "%s/%s%d", KEY_ROOT, "dir", i);
      42           0 :                 ksLookupByName (large, name, 0);
      43           0 :                 for (j = 0; j < NUM_KEY; j++)
      44             :                 {
      45           0 :                         snprintf (name, KEY_NAME_LENGTH, "%s/%s%d/%s%d", KEY_ROOT, "dir", i, "key", j);
      46           0 :                         ksLookupByName (large, name, 0);
      47             :                 }
      48             :         }
      49           0 : }
      50             : 
      51           0 : void benchmarkReread (void)
      52             : {
      53           0 :         kdbGet (kdb, large, key);
      54           0 : }
      55             : 
      56           0 : void benchmarkInwrite (void)
      57             : {
      58           0 :         kdbSet (kdb, large, key);
      59           0 : }
      60             : 
      61           0 : void benchmarkRewrite (void)
      62             : {
      63           0 :         kdbSet (kdb, large, key);
      64           0 : }
      65             : 
      66           0 : void benchmarkWriteout (void)
      67             : {
      68           0 :         kdbSet (kdb, large, key);
      69           0 : }
      70             : 
      71           0 : void benchmarkClose (void)
      72             : {
      73           0 :         kdbClose (kdb, key);
      74           0 : }
      75             : 
      76             : 
      77           0 : int main (void)
      78             : {
      79           0 :         key = keyNew (KEY_ROOT, KEY_END);
      80             : 
      81           0 :         timeInit ();
      82           0 :         benchmarkCreate ();
      83           0 :         timePrint ("Created empty keyset");
      84             : 
      85           0 :         benchmarkFillup ();
      86           0 :         timePrint ("New large keyset");
      87             : 
      88             :         benchmarkOpen ();
      89           0 :         keySetName (key, KEY_ROOT);
      90           0 :         timePrint ("Opened key database");
      91             : 
      92           0 :         benchmarkInread ();
      93           0 :         timePrint ("Initialize read");
      94             : 
      95             :         benchmarkInwrite ();
      96           0 :         timePrint ("Initialize write");
      97             : 
      98             :         benchmarkWriteout ();
      99           0 :         timePrint ("Write key database");
     100             : 
     101             :         benchmarkRewrite ();
     102           0 :         timePrint ("Rewrite key database");
     103             : 
     104           0 :         benchmarkReadin ();
     105           0 :         timePrint ("Read in key database");
     106             : 
     107           0 :         benchmarkLookupByName ();
     108           0 :         timePrint ("Lookup key database");
     109             : 
     110             :         benchmarkReread ();
     111           0 :         timePrint ("Re read key database");
     112             : 
     113             :         benchmarkClose ();
     114           0 :         timePrint ("Closed key database");
     115             : 
     116           0 :         ksDel (large);
     117           0 :         keyDel (key);
     118             : }

Generated by: LCOV version 1.13