fileop.c File Reference

Include dependency graph for fileop.c:

Go to the source code of this file.

Data Structures
struct	stat_struct

Macros
#define	PATH_MAX   255
#define	_STAT_CREATE   0
#define	_STAT_WRITE   1
#define	_STAT_CLOSE   2
#define	_STAT_LINK   3
#define	_STAT_UNLINK   4
#define	_STAT_DELETE   5
#define	_STAT_STAT   6
#define	_STAT_ACCESS   7
#define	_STAT_CHMOD   8
#define	_STAT_READDIR   9
#define	_STAT_DIR_CREATE   10
#define	_STAT_DIR_DELETE   11
#define	_STAT_READ   12
#define	_STAT_OPEN   13
#define	_STAT_DIR_TRAVERSE   14
#define	_NUM_STATS   15
#define	THISVERSION   " $Revision$"

Functions
static double	time_so_far (void)
void	dir_create (int)
void	dir_traverse (int)
void	dir_delete (int)
void	file_create (int)
void	file_stat (int)
void	file_access (int)
void	file_chmod (int)
void	file_readdir (int)
void	file_delete (int)
void	file_link (int)
void	file_unlink (int)
void	file_read (int)
void	splash (void)
void	usage (void)
void	bzero ()
void	clear_stats ()
int	validate (char *, int, char)
void	purge_buffer_cache ()
int	main (int argc, char **argv)

Variables
int	junk
int *	junkp
int	x
int	excel
int	verbose = 0
int	sz = 1
char *	mbuffer
int	incr = 1
struct stat_struct	stats [_NUM_STATS]
char	version [] =THISVERSION
char	thedir [PATH_MAX] ="."
const char *	mountname =NULL
int	cret
int	lower
int	upper
int	range
int	i
int	best
int	worst
int	dirlen

Macro Definition Documentation

_NUM_STATS

#define _NUM_STATS   15

Definition at line 98 of file fileop.c.

_STAT_ACCESS

#define _STAT_ACCESS   7

Definition at line 90 of file fileop.c.

_STAT_CHMOD

#define _STAT_CHMOD   8

Definition at line 91 of file fileop.c.

_STAT_CLOSE

#define _STAT_CLOSE   2

Definition at line 85 of file fileop.c.

_STAT_CREATE

#define _STAT_CREATE   0

Definition at line 83 of file fileop.c.

_STAT_DELETE

#define _STAT_DELETE   5

Definition at line 88 of file fileop.c.

_STAT_DIR_CREATE

#define _STAT_DIR_CREATE   10

Definition at line 93 of file fileop.c.

_STAT_DIR_DELETE

#define _STAT_DIR_DELETE   11

Definition at line 94 of file fileop.c.

_STAT_DIR_TRAVERSE

#define _STAT_DIR_TRAVERSE   14

Definition at line 97 of file fileop.c.

_STAT_LINK

#define _STAT_LINK   3

Definition at line 86 of file fileop.c.

_STAT_OPEN

#define _STAT_OPEN   13

Definition at line 96 of file fileop.c.

_STAT_READ

#define _STAT_READ   12

Definition at line 95 of file fileop.c.

_STAT_READDIR

#define _STAT_READDIR   9

Definition at line 92 of file fileop.c.

_STAT_STAT

#define _STAT_STAT   6

Definition at line 89 of file fileop.c.

_STAT_UNLINK

#define _STAT_UNLINK   4

Definition at line 87 of file fileop.c.

_STAT_WRITE

#define _STAT_WRITE   1

Definition at line 84 of file fileop.c.

PATH_MAX

#define PATH_MAX   255

Definition at line 68 of file fileop.c.

THISVERSION

#define THISVERSION   " $Revision$"

Definition at line 131 of file fileop.c.

Function Documentation

bzero()

void bzero

(

)

Here is the caller graph for this function:

clear_stats()

void clear_stats

(

)

Definition at line 1366 of file fileop.c.

{
    int i;
    for(i=0;i<_NUM_STATS;i++)
        bzero((char *)&stats[i],sizeof(struct stat_struct));
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_create()

void dir_create

(

int

x

)

Definition at line 594 of file fileop.c.

{
    int i,j,k;
    int ret;
    char buf[100];
    stats[_STAT_DIR_CREATE].best=(double)99999.9;
    stats[_STAT_DIR_CREATE].worst=(double)0.00000000;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      stats[_STAT_DIR_CREATE].starttime=time_so_far();
      ret=mkdir(buf,0777);
      if(ret < 0)
      {
          printf("Mkdir failed\n");
          exit(1);
      }
      stats[_STAT_DIR_CREATE].endtime=time_so_far();
      stats[_STAT_DIR_CREATE].speed=stats[_STAT_DIR_CREATE].endtime-stats[_STAT_DIR_CREATE].starttime;
      if(stats[_STAT_DIR_CREATE].speed < (double)0.0)
        stats[_STAT_DIR_CREATE].speed=(double)0.0;
      stats[_STAT_DIR_CREATE].total_time+=stats[_STAT_DIR_CREATE].speed;
      stats[_STAT_DIR_CREATE].counter++;
      if(stats[_STAT_DIR_CREATE].speed < stats[_STAT_DIR_CREATE].best)
        stats[_STAT_DIR_CREATE].best=stats[_STAT_DIR_CREATE].speed;
      if(stats[_STAT_DIR_CREATE].speed > stats[_STAT_DIR_CREATE].worst)
         stats[_STAT_DIR_CREATE].worst=stats[_STAT_DIR_CREATE].speed;
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        stats[_STAT_DIR_CREATE].starttime=time_so_far();
        ret=mkdir(buf,0777);
        if(ret < 0)
        {
          printf("Mkdir failed\n");
          exit(1);
        }
        stats[_STAT_DIR_CREATE].endtime=time_so_far();
        stats[_STAT_DIR_CREATE].speed=stats[_STAT_DIR_CREATE].endtime-stats[_STAT_DIR_CREATE].starttime;
        if(stats[_STAT_DIR_CREATE].speed < (double)0.0)
        stats[_STAT_DIR_CREATE].speed=(double) 0.0;
        stats[_STAT_DIR_CREATE].total_time+=stats[_STAT_DIR_CREATE].speed;
        stats[_STAT_DIR_CREATE].counter++;
        if(stats[_STAT_DIR_CREATE].speed < stats[_STAT_DIR_CREATE].best)
         stats[_STAT_DIR_CREATE].best=stats[_STAT_DIR_CREATE].speed;
        if(stats[_STAT_DIR_CREATE].speed > stats[_STAT_DIR_CREATE].worst)
         stats[_STAT_DIR_CREATE].worst=stats[_STAT_DIR_CREATE].speed;
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_dir_%d_%d_%d",i,j,k);
          stats[_STAT_DIR_CREATE].starttime=time_so_far();
          ret=mkdir(buf,0777);
          if(ret < 0)
          {
            printf("Mkdir failed\n");
            exit(1);
          }
          stats[_STAT_DIR_CREATE].endtime=time_so_far();
          stats[_STAT_DIR_CREATE].speed=stats[_STAT_DIR_CREATE].endtime-stats[_STAT_DIR_CREATE].starttime;
          if(stats[_STAT_DIR_CREATE].speed < (double)0.0)
        stats[_STAT_DIR_CREATE].speed=(double) 0.0;
          stats[_STAT_DIR_CREATE].total_time+=stats[_STAT_DIR_CREATE].speed;
          stats[_STAT_DIR_CREATE].counter++;
          if(stats[_STAT_DIR_CREATE].speed < stats[_STAT_DIR_CREATE].best)
         stats[_STAT_DIR_CREATE].best=stats[_STAT_DIR_CREATE].speed;
          if(stats[_STAT_DIR_CREATE].speed > stats[_STAT_DIR_CREATE].worst)
         stats[_STAT_DIR_CREATE].worst=stats[_STAT_DIR_CREATE].speed;
          junk=chdir(buf);
          junk=chdir("..");
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_delete()

void dir_delete

(

int

x

)

Definition at line 1099 of file fileop.c.

{
    int i,j,k;
    char buf[100];
    stats[_STAT_DIR_DELETE].best=(double)99999.9;
    stats[_STAT_DIR_DELETE].worst=(double)0.00000000;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_dir_%d_%d_%d",i,j,k);
          junk=chdir(buf);
          junk=chdir("..");
          stats[_STAT_DIR_DELETE].starttime=time_so_far();
          rmdir(buf);
          stats[_STAT_DIR_DELETE].endtime=time_so_far();
          stats[_STAT_DIR_DELETE].speed=stats[_STAT_DIR_DELETE].endtime-stats[_STAT_DIR_DELETE].starttime;
          if(stats[_STAT_DIR_DELETE].speed < (double)0.0)
        stats[_STAT_DIR_DELETE].speed=(double)0.0;
          stats[_STAT_DIR_DELETE].total_time+=stats[_STAT_DIR_DELETE].speed;
          stats[_STAT_DIR_DELETE].counter++;
          if(stats[_STAT_DIR_DELETE].speed < stats[_STAT_DIR_DELETE].best)
         stats[_STAT_DIR_DELETE].best=stats[_STAT_DIR_DELETE].speed;
          if(stats[_STAT_DIR_DELETE].speed > stats[_STAT_DIR_DELETE].worst)
         stats[_STAT_DIR_DELETE].worst=stats[_STAT_DIR_DELETE].speed;
        }
        junk=chdir("..");
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        stats[_STAT_DIR_DELETE].starttime=time_so_far();
        rmdir(buf);
        stats[_STAT_DIR_DELETE].endtime=time_so_far();
        stats[_STAT_DIR_DELETE].speed=stats[_STAT_DIR_DELETE].endtime-stats[_STAT_DIR_DELETE].starttime;
          if(stats[_STAT_DIR_DELETE].speed < (double)0.0)
        stats[_STAT_DIR_DELETE].speed=(double)0.0;
        stats[_STAT_DIR_DELETE].total_time+=stats[_STAT_DIR_DELETE].speed;
        stats[_STAT_DIR_DELETE].counter++;
        if(stats[_STAT_DIR_DELETE].speed < stats[_STAT_DIR_DELETE].best)
         stats[_STAT_DIR_DELETE].best=stats[_STAT_DIR_DELETE].speed;
        if(stats[_STAT_DIR_DELETE].speed > stats[_STAT_DIR_DELETE].worst)
         stats[_STAT_DIR_DELETE].worst=stats[_STAT_DIR_DELETE].speed;
      }
      junk=chdir("..");
      sprintf(buf,"fileop_L1_%d",i);
      stats[_STAT_DIR_DELETE].starttime=time_so_far();
      rmdir(buf);
      stats[_STAT_DIR_DELETE].endtime=time_so_far();
      stats[_STAT_DIR_DELETE].speed=stats[_STAT_DIR_DELETE].endtime-stats[_STAT_DIR_DELETE].starttime;
      if(stats[_STAT_DIR_DELETE].speed < (double)0.0)
        stats[_STAT_DIR_DELETE].speed=(double)0.0;
      stats[_STAT_DIR_DELETE].total_time+=stats[_STAT_DIR_DELETE].speed;
      stats[_STAT_DIR_DELETE].counter++;
      if(stats[_STAT_DIR_DELETE].speed < stats[_STAT_DIR_DELETE].best)
         stats[_STAT_DIR_DELETE].best=stats[_STAT_DIR_DELETE].speed;
      if(stats[_STAT_DIR_DELETE].speed > stats[_STAT_DIR_DELETE].worst)
         stats[_STAT_DIR_DELETE].worst=stats[_STAT_DIR_DELETE].speed;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

dir_traverse()

void dir_traverse

(

int

x

)

Definition at line 673 of file fileop.c.

{
    int i,j,k;
    char buf[100];
    double time1, time2;
    stats[_STAT_DIR_TRAVERSE].best=(double)99999.9;
    stats[_STAT_DIR_TRAVERSE].worst=(double)0.00000000;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
      junk=chdir(buf);
      stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
      time1=stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
        junk=chdir(buf);
        stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
        time2=stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_dir_%d_%d_%d",i,j,k);
          stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
          junk=chdir(buf);
          junk=chdir("..");
          stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
          stats[_STAT_DIR_TRAVERSE].speed=stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
          if(stats[_STAT_DIR_TRAVERSE].speed < (double)0.0)
        stats[_STAT_DIR_TRAVERSE].speed=(double) 0.0;
          stats[_STAT_DIR_TRAVERSE].total_time+=stats[_STAT_DIR_TRAVERSE].speed;
          stats[_STAT_DIR_TRAVERSE].counter++;
          if(stats[_STAT_DIR_TRAVERSE].speed < stats[_STAT_DIR_TRAVERSE].best)
         stats[_STAT_DIR_TRAVERSE].best=stats[_STAT_DIR_TRAVERSE].speed;
          if(stats[_STAT_DIR_TRAVERSE].speed > stats[_STAT_DIR_TRAVERSE].worst)
         stats[_STAT_DIR_TRAVERSE].worst=stats[_STAT_DIR_TRAVERSE].speed;
        }
        stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
        junk=chdir("..");
        stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
        stats[_STAT_DIR_TRAVERSE].speed=time2+stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
        if(stats[_STAT_DIR_TRAVERSE].speed < (double)0.0)
        stats[_STAT_DIR_TRAVERSE].speed=(double) 0.0;
        stats[_STAT_DIR_TRAVERSE].total_time+=stats[_STAT_DIR_TRAVERSE].speed;
        stats[_STAT_DIR_TRAVERSE].counter++;
        if(stats[_STAT_DIR_TRAVERSE].speed < stats[_STAT_DIR_TRAVERSE].best)
         stats[_STAT_DIR_TRAVERSE].best=stats[_STAT_DIR_TRAVERSE].speed;
        if(stats[_STAT_DIR_TRAVERSE].speed > stats[_STAT_DIR_TRAVERSE].worst)
         stats[_STAT_DIR_TRAVERSE].worst=stats[_STAT_DIR_TRAVERSE].speed;
      }
      stats[_STAT_DIR_TRAVERSE].starttime=time_so_far();
      junk=chdir("..");
      stats[_STAT_DIR_TRAVERSE].endtime=time_so_far();
      stats[_STAT_DIR_TRAVERSE].speed=time1+stats[_STAT_DIR_TRAVERSE].endtime-stats[_STAT_DIR_TRAVERSE].starttime;
      if(stats[_STAT_DIR_TRAVERSE].speed < (double)0.0)
        stats[_STAT_DIR_TRAVERSE].speed=(double)0.0;
      stats[_STAT_DIR_TRAVERSE].total_time+=stats[_STAT_DIR_TRAVERSE].speed;
      stats[_STAT_DIR_TRAVERSE].counter++;
      if(stats[_STAT_DIR_TRAVERSE].speed < stats[_STAT_DIR_TRAVERSE].best)
        stats[_STAT_DIR_TRAVERSE].best=stats[_STAT_DIR_TRAVERSE].speed;
      if(stats[_STAT_DIR_TRAVERSE].speed > stats[_STAT_DIR_TRAVERSE].worst)
         stats[_STAT_DIR_TRAVERSE].worst=stats[_STAT_DIR_TRAVERSE].speed;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_access()

void file_access

(

int

x

)

Definition at line 873 of file fileop.c.

{
    int i,j,k,y;
    char buf[100];
    stats[_STAT_ACCESS].best=(double)999999.9;
    stats[_STAT_ACCESS].worst=(double)0.0;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
          stats[_STAT_ACCESS].starttime=time_so_far();
          y=access(buf,W_OK|F_OK);
          if(y < 0)
          {
            printf("access failed\n");
        perror("what");
            exit(1);
          }
          stats[_STAT_ACCESS].endtime=time_so_far();
          stats[_STAT_ACCESS].speed=stats[_STAT_ACCESS].endtime-stats[_STAT_ACCESS].starttime;
          if(stats[_STAT_ACCESS].speed < (double)0.0)
        stats[_STAT_ACCESS].speed=(double)0.0;
          stats[_STAT_ACCESS].total_time+=stats[_STAT_ACCESS].speed;
          stats[_STAT_ACCESS].counter++;
          if(stats[_STAT_ACCESS].speed < stats[_STAT_ACCESS].best)
         stats[_STAT_ACCESS].best=stats[_STAT_ACCESS].speed;
          if(stats[_STAT_ACCESS].speed > stats[_STAT_ACCESS].worst)
         stats[_STAT_ACCESS].worst=stats[_STAT_ACCESS].speed;
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_chmod()

void file_chmod

(

int

x

)

Definition at line 916 of file fileop.c.

{
    int i,j,k,y;
    char buf[100];
    stats[_STAT_CHMOD].best=(double)999999.9;
    stats[_STAT_CHMOD].worst=(double)0.0;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
          stats[_STAT_CHMOD].starttime=time_so_far();
          y=chmod(buf,0666);
          if(y < 0)
          {
            printf("chmod failed\n");
        perror("what");
            exit(1);
          }
          stats[_STAT_CHMOD].endtime=time_so_far();
          stats[_STAT_CHMOD].speed=stats[_STAT_CHMOD].endtime-stats[_STAT_CHMOD].starttime;
          if(stats[_STAT_CHMOD].speed < (double)0.0)
        stats[_STAT_CHMOD].speed=(double)0.0;
          stats[_STAT_CHMOD].total_time+=stats[_STAT_CHMOD].speed;
          stats[_STAT_CHMOD].counter++;
          if(stats[_STAT_CHMOD].speed < stats[_STAT_CHMOD].best)
         stats[_STAT_CHMOD].best=stats[_STAT_CHMOD].speed;
          if(stats[_STAT_CHMOD].speed > stats[_STAT_CHMOD].worst)
         stats[_STAT_CHMOD].worst=stats[_STAT_CHMOD].speed;
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_create()

void file_create

(

int

x

)

Definition at line 740 of file fileop.c.

{
    int i,j,k;
    int fd;
    int ret;
    char buf[100];
    char value;
    stats[_STAT_CREATE].best=(double)999999.9;
    stats[_STAT_CREATE].worst=(double)0.0;
    stats[_STAT_WRITE].best=(double)999999.9;
    stats[_STAT_WRITE].worst=(double)0.0;
    stats[_STAT_CLOSE].best=(double)999999.9;
    stats[_STAT_CLOSE].worst=(double)0.0;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      ret=mkdir(buf,0777);
      if(ret < 0)
      {
          printf("Mkdir failed\n");
          exit(1);
      }
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        ret=mkdir(buf,0777);
        if(ret < 0)
        {
          printf("Mkdir failed\n");
          exit(1);
        }
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
          value=(char) ((i^j^k) & 0xff);
          memset(mbuffer,value,sz);
          stats[_STAT_CREATE].starttime=time_so_far();
          fd=creat(buf,O_RDWR|0600);
          if(fd < 0)
          {
            printf("Create failed\n");
            exit(1);
          }
          stats[_STAT_CREATE].endtime=time_so_far();
          stats[_STAT_CREATE].speed=stats[_STAT_CREATE].endtime-stats[_STAT_CREATE].starttime;
          if(stats[_STAT_CREATE].speed < (double)0.0)
        stats[_STAT_CREATE].speed=(double)0.0;
          stats[_STAT_CREATE].total_time+=stats[_STAT_CREATE].speed;
          stats[_STAT_CREATE].counter++;
          if(stats[_STAT_CREATE].speed < stats[_STAT_CREATE].best)
         stats[_STAT_CREATE].best=stats[_STAT_CREATE].speed;
          if(stats[_STAT_CREATE].speed > stats[_STAT_CREATE].worst)
         stats[_STAT_CREATE].worst=stats[_STAT_CREATE].speed;

          stats[_STAT_WRITE].starttime=time_so_far();
          junk=write(fd,mbuffer,sz);
          stats[_STAT_WRITE].endtime=time_so_far();
          stats[_STAT_WRITE].counter++;
          stats[_STAT_WRITE].speed=stats[_STAT_WRITE].endtime-stats[_STAT_WRITE].starttime;
          if(stats[_STAT_WRITE].speed < (double)0.0)
        stats[_STAT_WRITE].speed=(double)0.0;
          stats[_STAT_WRITE].total_time+=stats[_STAT_WRITE].speed;
          if(stats[_STAT_WRITE].speed < stats[_STAT_WRITE].best)
         stats[_STAT_WRITE].best=stats[_STAT_WRITE].speed;
          if(stats[_STAT_WRITE].speed > stats[_STAT_WRITE].worst)
         stats[_STAT_WRITE].worst=stats[_STAT_WRITE].speed;

          fsync(fd);
          stats[_STAT_CLOSE].starttime=time_so_far();
          close(fd);
          stats[_STAT_CLOSE].endtime=time_so_far();
          stats[_STAT_CLOSE].speed=stats[_STAT_CLOSE].endtime-stats[_STAT_CLOSE].starttime;
          if(stats[_STAT_CLOSE].speed < (double)0.0)
        stats[_STAT_CLOSE].speed=(double)0.0;
          stats[_STAT_CLOSE].total_time+=stats[_STAT_CLOSE].speed;
          stats[_STAT_CLOSE].counter++;
          if(stats[_STAT_CLOSE].speed < stats[_STAT_CLOSE].best)
         stats[_STAT_CLOSE].best=stats[_STAT_CLOSE].speed;
          if(stats[_STAT_CLOSE].speed > stats[_STAT_CLOSE].worst)
         stats[_STAT_CLOSE].worst=stats[_STAT_CLOSE].speed;
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_delete()

void file_delete

(

int

x

)

Definition at line 1164 of file fileop.c.

{
    int i,j,k;
    char buf[100];
    stats[_STAT_DELETE].best=(double)999999.9;
    stats[_STAT_DELETE].worst=(double)0.0;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
          stats[_STAT_DELETE].starttime=time_so_far();
          unlink(buf);
          stats[_STAT_DELETE].endtime=time_so_far();
          stats[_STAT_DELETE].speed=stats[_STAT_DELETE].endtime-stats[_STAT_DELETE].starttime;
          if(stats[_STAT_DELETE].speed < (double)0.0)
        stats[_STAT_DELETE].speed=(double)0.0;
          stats[_STAT_DELETE].total_time+=stats[_STAT_DELETE].speed;
          stats[_STAT_DELETE].counter++;
          if(stats[_STAT_DELETE].speed < stats[_STAT_DELETE].best)
         stats[_STAT_DELETE].best=stats[_STAT_DELETE].speed;
          if(stats[_STAT_DELETE].speed > stats[_STAT_DELETE].worst)
         stats[_STAT_DELETE].worst=stats[_STAT_DELETE].speed;
        }
        junk=chdir("..");
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        rmdir(buf);
      }
      junk=chdir("..");
      sprintf(buf,"fileop_L1_%d",i);
      rmdir(buf);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_link()

void file_link

(

int

x

)

Definition at line 1011 of file fileop.c.

{
    int i,j,k,y;
    char buf[100];
    char bufn[100];
    stats[_STAT_LINK].best=(double)999999.9;
    stats[_STAT_LINK].worst=(double)0.0;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
          sprintf(bufn,"fileop_file_%d_%d_%dL",i,j,k);
          stats[_STAT_LINK].starttime=time_so_far();
          y=link(buf,bufn);
          if(y < 0)
          {
            printf("Link failed\n");
            exit(1);
          }
          stats[_STAT_LINK].endtime=time_so_far();
          stats[_STAT_LINK].speed=stats[_STAT_LINK].endtime-stats[_STAT_LINK].starttime;
          if(stats[_STAT_LINK].speed < (double)0.0)
        stats[_STAT_LINK].speed=(double)0.0;
          stats[_STAT_LINK].total_time+=stats[_STAT_LINK].speed;
          stats[_STAT_LINK].counter++;
          if(stats[_STAT_LINK].speed < stats[_STAT_LINK].best)
         stats[_STAT_LINK].best=stats[_STAT_LINK].speed;
          if(stats[_STAT_LINK].speed > stats[_STAT_LINK].worst)
         stats[_STAT_LINK].worst=stats[_STAT_LINK].speed;
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_read()

void file_read

(

int

x

)

Definition at line 1204 of file fileop.c.

{
    int i,j,k,y,fd;
    char buf[100];
    char value;
    stats[_STAT_READ].best=(double)99999.9;
    stats[_STAT_READ].worst=(double)0.00000000;
    stats[_STAT_OPEN].best=(double)99999.9;
    stats[_STAT_OPEN].worst=(double)0.00000000;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
          value=(char)((i^j^k) &0xff);
          stats[_STAT_OPEN].starttime=time_so_far();
          fd=open(buf,O_RDONLY);
          if(fd < 0)
          {
            printf("Open failed\n");
            exit(1);
          }
          stats[_STAT_OPEN].endtime=time_so_far();
          stats[_STAT_OPEN].speed=stats[_STAT_OPEN].endtime-stats[_STAT_OPEN].starttime;
          if(stats[_STAT_OPEN].speed < (double)0.0)
        stats[_STAT_OPEN].speed=(double)0.0;
          stats[_STAT_OPEN].total_time+=stats[_STAT_OPEN].speed;
          stats[_STAT_OPEN].counter++;
          if(stats[_STAT_OPEN].speed < stats[_STAT_OPEN].best)
         stats[_STAT_OPEN].best=stats[_STAT_OPEN].speed;
          if(stats[_STAT_OPEN].speed > stats[_STAT_OPEN].worst)
         stats[_STAT_OPEN].worst=stats[_STAT_OPEN].speed;

          stats[_STAT_READ].starttime=time_so_far();
          y=read(fd,mbuffer,sz);
          if(y < 0)
          {
            printf("Read failed\n");
            exit(1);
          }
          if(validate(mbuffer,sz, value) !=0)
        printf("Error: Data Mis-compare\n");;
          stats[_STAT_READ].endtime=time_so_far();
          close(fd);
          stats[_STAT_READ].speed=stats[_STAT_READ].endtime-stats[_STAT_READ].starttime;
          if(stats[_STAT_READ].speed < (double)0.0)
        stats[_STAT_READ].speed=(double)0.0;
          stats[_STAT_READ].total_time+=stats[_STAT_READ].speed;
          stats[_STAT_READ].counter++;
          if(stats[_STAT_READ].speed < stats[_STAT_READ].best)
         stats[_STAT_READ].best=stats[_STAT_READ].speed;
          if(stats[_STAT_READ].speed > stats[_STAT_READ].worst)
         stats[_STAT_READ].worst=stats[_STAT_READ].speed;
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_readdir()

void file_readdir

(

int

x

)

Definition at line 959 of file fileop.c.

{
    int i,j,ret1;
    char buf[100];
    DIR *dirbuf;
    struct dirent *y;
    stats[_STAT_READDIR].best=(double)999999.9;
    stats[_STAT_READDIR].worst=(double)0.0;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        dirbuf=opendir(".");
        if(dirbuf==0)
        {
        printf("opendir failed\n");
        exit(1);
        }
        stats[_STAT_READDIR].starttime=time_so_far();
        y=readdir(dirbuf);
        if(y == 0)
        {
          printf("readdir failed\n");
          exit(1);
        }
        stats[_STAT_READDIR].endtime=time_so_far();
        stats[_STAT_READDIR].speed=stats[_STAT_READDIR].endtime-stats[_STAT_READDIR].starttime;
          if(stats[_STAT_READDIR].speed < (double)0.0)
        stats[_STAT_READDIR].speed=(double)0.0;
        stats[_STAT_READDIR].total_time+=stats[_STAT_READDIR].speed;
        stats[_STAT_READDIR].counter++;
        if(stats[_STAT_READDIR].speed < stats[_STAT_READDIR].best)
         stats[_STAT_READDIR].best=stats[_STAT_READDIR].speed;
        if(stats[_STAT_READDIR].speed > stats[_STAT_READDIR].worst)
         stats[_STAT_READDIR].worst=stats[_STAT_READDIR].speed;
        ret1=closedir(dirbuf);
        if(ret1 < 0)
        {
          printf("closedir failed\n");
          exit(1);
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_stat()

void file_stat

(

int

x

)

Definition at line 830 of file fileop.c.

{
    int i,j,k,y;
    char buf[100];
    struct stat mystat;
    stats[_STAT_STAT].best=(double)99999.9;
    stats[_STAT_STAT].worst=(double)0.00000000;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
          stats[_STAT_STAT].starttime=time_so_far();
          y=stat(buf,&mystat);
          if(y < 0)
          {
            printf("Stat failed\n");
            exit(1);
          }
          stats[_STAT_STAT].endtime=time_so_far();
          stats[_STAT_STAT].speed=stats[_STAT_STAT].endtime-stats[_STAT_STAT].starttime;
          if(stats[_STAT_STAT].speed < (double)0.0)
        stats[_STAT_STAT].speed=(double)0.0;
          stats[_STAT_STAT].total_time+=stats[_STAT_STAT].speed;
          stats[_STAT_STAT].counter++;
          if(stats[_STAT_STAT].speed < stats[_STAT_STAT].best)
         stats[_STAT_STAT].best=stats[_STAT_STAT].speed;
          if(stats[_STAT_STAT].speed > stats[_STAT_STAT].worst)
         stats[_STAT_STAT].worst=stats[_STAT_STAT].speed;
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

file_unlink()

void file_unlink

(

int

x

)

Definition at line 1055 of file fileop.c.

{
    int i,j,k,y;
    char buf[100];
    char bufn[100];
    stats[_STAT_UNLINK].best=(double)999999.9;
    stats[_STAT_UNLINK].worst=(double)0.0;
    for(i=0;i<x;i++)
    {
      sprintf(buf,"fileop_L1_%d",i);
      junk=chdir(buf);
      for(j=0;j<x;j++)
      {
        sprintf(buf,"fileop_L1_%d_L2_%d",i,j);
        junk=chdir(buf);
        for(k=0;k<x;k++)
        {
          sprintf(buf,"fileop_file_%d_%d_%d",i,j,k);
          sprintf(bufn,"fileop_file_%d_%d_%dL",i,j,k);
          stats[_STAT_UNLINK].starttime=time_so_far();
          y=unlink(bufn);
          if(y < 0)
          {
            printf("Unlink failed\n");
            exit(1);
          }
          stats[_STAT_UNLINK].endtime=time_so_far();
          stats[_STAT_UNLINK].speed=stats[_STAT_UNLINK].endtime-stats[_STAT_UNLINK].starttime;
          if(stats[_STAT_UNLINK].speed < (double)0.0)
        stats[_STAT_UNLINK].speed=(double)0.0;
          stats[_STAT_UNLINK].total_time+=stats[_STAT_UNLINK].speed;
          stats[_STAT_UNLINK].counter++;
          if(stats[_STAT_UNLINK].speed < stats[_STAT_UNLINK].best)
         stats[_STAT_UNLINK].best=stats[_STAT_UNLINK].speed;
          if(stats[_STAT_UNLINK].speed > stats[_STAT_UNLINK].worst)
         stats[_STAT_UNLINK].worst=stats[_STAT_UNLINK].speed;
        }
        junk=chdir("..");
      }
      junk=chdir("..");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 176 of file fileop.c.

{
    if(argc == 1)
    {
        usage();
        exit(1);
    }
    while((cret = getopt(argc,argv,"hbwetvf:s:l:u:d:U:i: ")) != EOF){
        switch(cret){
                case 'h':
                        usage();
                        exit(0);
                        break;
                case 'd' :
                        dirlen=strlen(optarg);
                        if (optarg[dirlen-1]=='/')
                          --dirlen;
                        strncpy(thedir, optarg, dirlen);
            thedir[dirlen] = 0;
                        break;
        case 'U':
            mountname = optarg;
            break;
        case 'i':   /* Increment force by */
            incr=atoi(optarg);
            if(incr < 0)
                incr=1;
            break;
        case 'f':   /* Force factor */
            x=atoi(optarg);
            if(x < 0)
                x=1;
            break;
        case 's':   /* Size of files */
                        sz=atoi(optarg);
                        if(optarg[strlen(optarg)-1]=='k' ||
                                optarg[strlen(optarg)-1]=='K'){
                                sz = (1024 * atoi(optarg));
                        }
                        if(optarg[strlen(optarg)-1]=='m' ||
                                optarg[strlen(optarg)-1]=='M'){
                                sz = (1024 * 1024 * atoi(optarg));
                        }
            if(sz < 0)
                sz=1;
            break;
        case 'l':   /* lower force value */
            lower=atoi(optarg);
            range=1;
            if(lower < 0)
                lower=1;
            break;
        case 'v':   /* version */
            splash();
            exit(0);
            break;
        case 'u':   /* upper force value */
            upper=atoi(optarg);
            range=1;
            if(upper < 0)
                upper=1;
            break;
        case 't':   /* verbose */
            verbose=1;
            break;
        case 'e':   /* Excel */
            excel=1;
            break;
        case 'b':   /* Best */
            best=1;
            break;
        case 'w':   /* Worst */
            worst=1;
            break;
        }
    }
    mbuffer=(char *)malloc(sz);
    memset(mbuffer,'a',sz);
    if(!excel)
      printf("\nFileop:  Working in %s, File size is %d,  Output is in Ops/sec. (A=Avg, B=Best, W=Worst)\n", thedir, sz);
    if(!verbose)
    {
#ifdef Windows
        printf(" .     %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %10s\n",
            "mkdir","chdir","rmdir","create","open","read","write","close","stat",
        "access","chmod","readdir","delete"," Total_files");
#else

        printf(" .     %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %7s %10s\n",
            "mkdir","chdir","rmdir","create","open", "read","write","close","stat",
        "access","chmod","readdir","link  ","unlink","delete",
        " Total_files");
#endif
    }
    junk=chdir(thedir); /* change starting point */
    if(x==0)
        x=1;
    if(range==0)
        lower=upper=x;
    for(i=lower;i<=upper;i+=incr)
    {
        clear_stats();
        x=i;
       /*
        * Dir Create test 
        */
       purge_buffer_cache();
       dir_create(x);

       if(verbose)
       {
          printf("mkdir:   Dirs = %9lld ",stats[_STAT_DIR_CREATE].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_DIR_CREATE].total_time);
          printf("         Avg mkdir(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_DIR_CREATE].counter/stats[_STAT_DIR_CREATE].total_time,
            stats[_STAT_DIR_CREATE].total_time/stats[_STAT_DIR_CREATE].counter);
          printf("         Best mkdir(s)/sec    = %12.2f (%12.9f seconds/op)\n",1/stats[_STAT_DIR_CREATE].best,stats[_STAT_DIR_CREATE].best);
          printf("         Worst mkdir(s)/sec   = %12.2f (%12.9f seconds/op)\n\n",1/stats[_STAT_DIR_CREATE].worst,stats[_STAT_DIR_CREATE].worst);
       }

       /*
        * Dir Traverse test
        */
       purge_buffer_cache();
       dir_traverse(x);

       if(verbose)
       {
          printf("chdir:   Dirs = %9lld ",stats[_STAT_DIR_TRAVERSE].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_DIR_TRAVERSE].total_time);
          printf("         Avg chdir(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_DIR_TRAVERSE].counter/stats[_STAT_DIR_TRAVERSE].total_time,
            stats[_STAT_DIR_TRAVERSE].total_time/stats[_STAT_DIR_TRAVERSE].counter);
          printf("         Best chdir(s)/sec    = %12.2f (%12.9f seconds/op)\n",1/stats[_STAT_DIR_TRAVERSE].best,stats[_STAT_DIR_TRAVERSE].best);
          printf("         Worst chdir(s)/sec   = %12.2f (%12.9f seconds/op)\n\n",1/stats[_STAT_DIR_TRAVERSE].worst,stats[_STAT_DIR_TRAVERSE].worst);
       }

       /*
        * Dir delete test
        */
       purge_buffer_cache();
       dir_delete(x);

       if(verbose)
       {
       printf("rmdir:   Dirs = %9lld ",stats[_STAT_DIR_DELETE].counter);
       printf("Total Time = %12.9f seconds\n",stats[_STAT_DIR_DELETE].total_time);
       printf("         Avg rmdir(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_DIR_DELETE].counter/stats[_STAT_DIR_DELETE].total_time,
            stats[_STAT_DIR_DELETE].total_time/stats[_STAT_DIR_DELETE].counter);
       printf("         Best rmdir(s)/sec    = %12.2f (%12.9f seconds/op)\n",1/stats[_STAT_DIR_DELETE].best,stats[_STAT_DIR_DELETE].best);
       printf("         Worst rmdir(s)/sec   = %12.2f (%12.9f seconds/op)\n\n",1/stats[_STAT_DIR_DELETE].worst,stats[_STAT_DIR_DELETE].worst);
       }

       /*
        * Create test 
        */
       purge_buffer_cache();
       file_create(x);
       if(verbose)
       {
          printf("create:  Files = %9lld ",stats[_STAT_CREATE].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_CREATE].total_time);
          printf("         Avg create(s)/sec    = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_CREATE].counter/stats[_STAT_CREATE].total_time,
            stats[_STAT_CREATE].total_time/stats[_STAT_CREATE].counter);
          printf("         Best create(s)/sec   = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_CREATE].best,stats[_STAT_CREATE].best);
          printf("         Worst create(s)/sec  = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_CREATE].worst,stats[_STAT_CREATE].worst);
          printf("write:   Files = %9lld ",stats[_STAT_WRITE].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_WRITE].total_time);
          printf("         Avg write(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_WRITE].counter/stats[_STAT_WRITE].total_time,
            stats[_STAT_WRITE].total_time/stats[_STAT_WRITE].counter);
          printf("         Best write(s)/sec    = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_WRITE].best,stats[_STAT_WRITE].best);
          printf("         Worst write(s)/sec   = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_WRITE].worst,stats[_STAT_WRITE].worst);
          printf("close:   Files = %9lld ",stats[_STAT_CLOSE].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_CLOSE].total_time);
          printf("         Avg close(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_CLOSE].counter/stats[_STAT_CLOSE].total_time,
            stats[_STAT_CLOSE].total_time/stats[_STAT_CLOSE].counter);
          printf("         Best close(s)/sec    = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_CLOSE].best,stats[_STAT_CLOSE].best);
          printf("         Worst close(s)/sec   = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_CLOSE].worst,stats[_STAT_CLOSE].worst);
       }

       /*
        * Stat test 
        */
       purge_buffer_cache();
       file_stat(x);

       if(verbose)
       {
          printf("stat:    Files = %9lld ",stats[_STAT_STAT].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_STAT].total_time);
          printf("         Avg stat(s)/sec      = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_STAT].counter/stats[_STAT_STAT].total_time,
            stats[_STAT_STAT].total_time/stats[_STAT_STAT].counter);
          printf("         Best stat(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_STAT].best,stats[_STAT_STAT].best);
          printf("         Worst stat(s)/sec    = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_STAT].worst,stats[_STAT_STAT].worst);
       }
       /*
        * Read test 
        */
       purge_buffer_cache();
       file_read(x);

       if(verbose)
       {
          printf("open:    Files = %9lld ",stats[_STAT_OPEN].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_OPEN].total_time);
          printf("         Avg open(s)/sec      = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_OPEN].counter/stats[_STAT_OPEN].total_time,
            stats[_STAT_OPEN].total_time/stats[_STAT_OPEN].counter);
          printf("         Best open(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_OPEN].best,stats[_STAT_OPEN].best);
          printf("         Worst open(s)/sec    = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_OPEN].worst,stats[_STAT_OPEN].worst);

          printf("read:    Files = %9lld ",stats[_STAT_READ].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_READ].total_time);
          printf("         Avg read(s)/sec      = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_READ].counter/stats[_STAT_READ].total_time,
            stats[_STAT_READ].total_time/stats[_STAT_READ].counter);
          printf("         Best read(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_READ].best,stats[_STAT_READ].best);
          printf("         Worst read(s)/sec    = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_READ].worst,stats[_STAT_READ].worst);
       }

       /*
        * Access test 
        */
       purge_buffer_cache();
       file_access(x);
       if(verbose)
       {
          printf("access:  Files = %9lld ",stats[_STAT_ACCESS].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_ACCESS].total_time);
          printf("         Avg access(s)/sec    = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_ACCESS].counter/stats[_STAT_ACCESS].total_time,
            stats[_STAT_ACCESS].total_time/stats[_STAT_ACCESS].counter);
          printf("         Best access(s)/sec   = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_ACCESS].best,stats[_STAT_ACCESS].best);
          printf("         Worst access(s)/sec  = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_ACCESS].worst,stats[_STAT_ACCESS].worst);
       }
       /*
        * Chmod test 
        */
       purge_buffer_cache();
       file_chmod(x);

       if(verbose)
       {
          printf("chmod:   Files = %9lld ",stats[_STAT_CHMOD].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_CHMOD].total_time);
          printf("         Avg chmod(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_CHMOD].counter/stats[_STAT_CHMOD].total_time,
            stats[_STAT_CHMOD].total_time/stats[_STAT_CHMOD].counter);
          printf("         Best chmod(s)/sec    = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_CHMOD].best,stats[_STAT_CHMOD].best);
          printf("         Worst chmod(s)/sec   = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_CHMOD].worst,stats[_STAT_CHMOD].worst);
       }
       /*
        * readdir test 
        */
       purge_buffer_cache();
       file_readdir(x);

       if(verbose)
       {
          printf("readdir: Files = %9lld ",stats[_STAT_READDIR].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_READDIR].total_time);
          printf("         Avg readdir(s)/sec   = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_READDIR].counter/stats[_STAT_READDIR].total_time,
            stats[_STAT_READDIR].total_time/stats[_STAT_READDIR].counter);
          printf("         Best readdir(s)/sec  = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_READDIR].best,stats[_STAT_READDIR].best);
          printf("         Worst readdir(s)/sec = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_READDIR].worst,stats[_STAT_READDIR].worst);
       }
#if !defined(Windows)
       /*
        * link test 
        */
       purge_buffer_cache();
       file_link(x);
       if(verbose)
       {
          printf("link:    Files = %9lld ",stats[_STAT_LINK].counter);
          printf("Total Time = %12.9f seconds\n",stats[_STAT_LINK].total_time);
          printf("         Avg link(s)/sec      = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_LINK].counter/stats[_STAT_LINK].total_time,
            stats[_STAT_LINK].total_time/stats[_STAT_LINK].counter);
          printf("         Best link(s)/sec     = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_LINK].best,stats[_STAT_LINK].best);
          printf("         Worst link(s)/sec    = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_LINK].worst,stats[_STAT_LINK].worst);
       }
       /*
        * unlink test 
        */
       purge_buffer_cache();
       file_unlink(x);
       if(verbose)
       {
          printf("unlink:  Files = %9lld ",stats[_STAT_UNLINK].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_UNLINK].total_time);
          printf("         Avg unlink(s)/sec    = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_UNLINK].counter/stats[_STAT_UNLINK].total_time,
            stats[_STAT_UNLINK].total_time/stats[_STAT_UNLINK].counter);
          printf("         Best unlink(s)/sec   = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_UNLINK].best,stats[_STAT_UNLINK].best);
          printf("         Worst unlink(s)/sec  = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_UNLINK].worst,stats[_STAT_UNLINK].worst);
       }
#endif
       /*
        * Delete test 
        */
       purge_buffer_cache();
       file_delete(x);
       if(verbose)
       {
          printf("delete:  Files = %9lld ",stats[_STAT_DELETE].counter);
          printf("Total Time = %12.9f seconds\n", stats[_STAT_DELETE].total_time);
          printf("         Avg delete(s)/sec    = %12.2f (%12.9f seconds/op)\n",
            stats[_STAT_DELETE].counter/stats[_STAT_DELETE].total_time,
            stats[_STAT_DELETE].total_time/stats[_STAT_DELETE].counter);
          printf("         Best delete(s)/sec   = %12.2f (%12.9f seconds/op)\n",
            1/stats[_STAT_DELETE].best,stats[_STAT_DELETE].best);
          printf("         Worst delete(s)/sec  = %12.2f (%12.9f seconds/op)\n\n",
            1/stats[_STAT_DELETE].worst,stats[_STAT_DELETE].worst);
       }
       if(!verbose)
       {
             printf("%c %4d %7.0f ",'A',x,stats[_STAT_DIR_CREATE].counter/stats[_STAT_DIR_CREATE].total_time);
             printf("%7.0f ",stats[_STAT_DIR_TRAVERSE].counter/stats[_STAT_DIR_TRAVERSE].total_time);
             printf("%7.0f ",stats[_STAT_DIR_DELETE].counter/stats[_STAT_DIR_DELETE].total_time);
             printf("%7.0f ",stats[_STAT_CREATE].counter/stats[_STAT_CREATE].total_time);
             printf("%7.0f ",stats[_STAT_OPEN].counter/stats[_STAT_OPEN].total_time);
             printf("%7.0f ",stats[_STAT_READ].counter/stats[_STAT_READ].total_time);
             printf("%7.0f ",stats[_STAT_WRITE].counter/stats[_STAT_WRITE].total_time);
             printf("%7.0f ",stats[_STAT_CLOSE].counter/stats[_STAT_CLOSE].total_time);
             printf("%7.0f ",stats[_STAT_STAT].counter/stats[_STAT_STAT].total_time);
             printf("%7.0f ",stats[_STAT_ACCESS].counter/stats[_STAT_ACCESS].total_time);
             printf("%7.0f ",stats[_STAT_CHMOD].counter/stats[_STAT_CHMOD].total_time);
             printf("%7.0f ",stats[_STAT_READDIR].counter/stats[_STAT_READDIR].total_time);
#ifndef Windows
             printf("%7.0f ",stats[_STAT_LINK].counter/stats[_STAT_LINK].total_time);
             printf("%7.0f ",stats[_STAT_UNLINK].counter/stats[_STAT_UNLINK].total_time);
#endif
             printf("%7.0f ",stats[_STAT_DELETE].counter/stats[_STAT_DELETE].total_time);
             printf("%10d ",x*x*x);
             printf("\n");
         fflush(stdout);

        if(best)
        {
             printf("%c %4d %7.0f ",'B',x, 1/stats[_STAT_DIR_CREATE].best);
             printf("%7.0f ",1/stats[_STAT_DIR_TRAVERSE].best);
             printf("%7.0f ",1/stats[_STAT_DIR_DELETE].best);
             printf("%7.0f ",1/stats[_STAT_CREATE].best);
             printf("%7.0f ",1/stats[_STAT_OPEN].best);
             printf("%7.0f ",1/stats[_STAT_READ].best);
             printf("%7.0f ",1/stats[_STAT_WRITE].best);
             printf("%7.0f ",1/stats[_STAT_CLOSE].best);
             printf("%7.0f ",1/stats[_STAT_STAT].best);
             printf("%7.0f ",1/stats[_STAT_ACCESS].best);
             printf("%7.0f ",1/stats[_STAT_CHMOD].best);
             printf("%7.0f ",1/stats[_STAT_READDIR].best);
#ifndef Windows
             printf("%7.0f ",1/stats[_STAT_LINK].best);
             printf("%7.0f ",1/stats[_STAT_UNLINK].best);
#endif
             printf("%7.0f ",1/stats[_STAT_DELETE].best);
             printf("%10d ",x*x*x);
         printf("\n");
         fflush(stdout);
        }
        if(worst)
        {
             printf("%c %4d %7.0f ",'W',x, 1/stats[_STAT_DIR_CREATE].worst);
             printf("%7.0f ",1/stats[_STAT_DIR_TRAVERSE].worst);
             printf("%7.0f ",1/stats[_STAT_DIR_DELETE].worst);
             printf("%7.0f ",1/stats[_STAT_CREATE].worst);
             printf("%7.0f ",1/stats[_STAT_OPEN].worst);
             printf("%7.0f ",1/stats[_STAT_READ].worst);
             printf("%7.0f ",1/stats[_STAT_WRITE].worst);
             printf("%7.0f ",1/stats[_STAT_CLOSE].worst);
             printf("%7.0f ",1/stats[_STAT_STAT].worst);
             printf("%7.0f ",1/stats[_STAT_ACCESS].worst);
             printf("%7.0f ",1/stats[_STAT_CHMOD].worst);
             printf("%7.0f ",1/stats[_STAT_READDIR].worst);
#ifndef Windows
             printf("%7.0f ",1/stats[_STAT_LINK].worst);
             printf("%7.0f ",1/stats[_STAT_UNLINK].worst);
#endif
             printf("%7.0f ",1/stats[_STAT_DELETE].worst);
             printf("%10d ",x*x*x);
         printf("\n");
         fflush(stdout);
        }
       }
    }
    return(0);
}

Here is the call graph for this function:

purge_buffer_cache()

void purge_buffer_cache

(

)

Definition at line 147 of file fileop.c.

{
    if (!mountname)
        return;

    char cwd[PATH_MAX];
    char command[1024];
    int ret,i;

    junkp=(int *)getcwd(cwd, sizeof(cwd));
    junk=chdir("/");
    strcpy(command,"umount ");
    strcat(command, mountname);
        /*
           umount might fail if the device is still busy, so
           retry unmounting several times with increasing delays
        */
        for (i = 1; i < 10; ++i) {
               ret = system(command);
               if (ret == 0)
                       break;
               sleep(i); /* seconds */
        }
    strcpy(command,"mount ");
    strcat(command, mountname);
    junk=system(command);
    junk=chdir(cwd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

splash()

void splash

(

void

)

Definition at line 1315 of file fileop.c.

{
    printf("\n");
    printf("     --------------------------------------\n");
    printf("     |              Fileop                | \n");
    printf("     | %s          | \n",version);
    printf("     |                                    | \n");
    printf("     |                by                  |\n");
    printf("     |                                    | \n");
    printf("     |             Don Capps              |\n");
    printf("     --------------------------------------\n");
    printf("\n");
}

Here is the caller graph for this function:

time_so_far()

static double time_so_far ( void  )

static

Definition at line 1279 of file fileop.c.

{
#ifdef Windows
   LARGE_INTEGER freq,counter;
   double wintime,bigcounter;
    /* For Windows the time_of_day() is useless. It increments in 55 milli second   */
    /* increments. By using the Win32api one can get access to the high performance */
    /* measurement interfaces. With this one can get back into the 8 to 9       */
    /* microsecond resolution.                          */
        QueryPerformanceFrequency(&freq);
        QueryPerformanceCounter(&counter);
        bigcounter=(double)counter.HighPart *(double)0xffffffff +
                (double)counter.LowPart;
        wintime = (double)(bigcounter/(double)freq.LowPart);
        return((double)wintime);
#else
#if defined (OSFV4) || defined(OSFV3) || defined(OSFV5)
  struct timespec gp;

  if (getclock(TIMEOFDAY, (struct timespec *) &gp) == -1)
    perror("getclock");
  return (( (double) (gp.tv_sec)) +
    ( ((float)(gp.tv_nsec)) * 0.000000001 ));
#else
  struct timeval tp;

  if (gettimeofday(&tp, (struct timezone *) NULL) == -1)
    perror("gettimeofday");
  return ((double) (tp.tv_sec)) +
    (((double) tp.tv_usec) * 0.000001 );
#endif
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

usage()

void usage

(

void

)

Definition at line 1330 of file fileop.c.

{
  splash();
  printf("     fileop [-f X ]|[-l # -u #] [-s Y] [-e] [-b] [-w] [-d <dir>] [-t] [-v] [-h]\n");
  printf("\n");
  printf("     -f #      Force factor. X^3 files will be created and removed.\n");
  printf("     -l #      Lower limit on the value of the Force factor.\n");
  printf("     -u #      Upper limit on the value of the Force factor.\n");
  printf("     -s #      Optional. Sets filesize for the create/write. May use suffix 'K' or 'M'.\n");
  printf("     -e        Excel importable format.\n");
  printf("     -b        Output best case results.\n");
  printf("     -i #      Increment force factor by this increment.\n");
  printf("     -w        Output worst case results.\n");
  printf("     -d <dir>  Specify starting directory.\n");
  printf("     -U <dir>  Mount point to remount between tests.\n");
  printf("     -t        Verbose output option.\n");
  printf("     -v        Version information.\n");
  printf("     -h        Help text.\n");
  printf("\n");
  printf("     The structure of the file tree is:\n");
  printf("     X number of Level 1 directories, with X number of\n");
  printf("     level 2 directories, with X number of files in each\n");
  printf("     of the level 2 directories.\n");
  printf("\n");
  printf("     Example:  fileop 2\n");
  printf("\n");
  printf("             dir_1                        dir_2\n");
  printf("            /     \\                      /     \\ \n");
  printf("      sdir_1       sdir_2          sdir_1       sdir_2\n");
  printf("      /     \\     /     \\          /     \\      /     \\ \n");
  printf("   file_1 file_2 file_1 file_2   file_1 file_2 file_1 file_2\n");
  printf("\n");
  printf("   Each file will be created, and then Y bytes is written to the file.\n");
  printf("\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

validate()

int validate	(	char *	buffer,
		int	size,
		char	value
	)

Definition at line 1373 of file fileop.c.

{
    register int i;
    register char *cp;
    register int size1;
    register char v1;
    v1=value;
    cp = buffer;
    size1=size;
    for(i=0;i<size;i++)
    {
        if(*cp++ != v1)
            return(1);
    }
    return(0);
}

Here is the caller graph for this function:

Variable Documentation

best

int best

Definition at line 141 of file fileop.c.

cret

int cret

Definition at line 138 of file fileop.c.

dirlen

int dirlen

Definition at line 142 of file fileop.c.

excel

int excel

Definition at line 78 of file fileop.c.

i

int i

Definition at line 140 of file fileop.c.

incr

int incr = 1

Definition at line 82 of file fileop.c.

junk

int junk

Definition at line 77 of file fileop.c.

junkp

int * junkp

Definition at line 77 of file fileop.c.

lower

int lower

Definition at line 139 of file fileop.c.

mbuffer

char* mbuffer

Definition at line 81 of file fileop.c.

mountname

const char* mountname =NULL

Definition at line 136 of file fileop.c.

range

int range

Definition at line 139 of file fileop.c.

stats

struct stat_struct stats[_NUM_STATS]

sz

int sz = 1

Definition at line 80 of file fileop.c.

thedir

char thedir[PATH_MAX] ="."

Definition at line 135 of file fileop.c.

upper

int upper

Definition at line 139 of file fileop.c.

verbose

int verbose = 0

Definition at line 79 of file fileop.c.

version

char version[] =THISVERSION

Definition at line 134 of file fileop.c.

worst

int worst

Definition at line 141 of file fileop.c.

x

int x

Definition at line 78 of file fileop.c.