viced: Rationalise FS_STATS_DETAILED logging
[openafs.git] / src / viced / fsstats.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /* An abstracted interface for recording fs statistics data */
11
12 #include <afsconfig.h>
13 #include <afs/param.h>
14
15 #include <roken.h>
16
17 #include <afs/afsint.h>
18 #include <afs/ihandle.h>
19 #include <afs/nfs.h>
20 #include "viced.h"
21 #include "fs_stats.h"
22
23 #if FS_STATS_DETAILED
24
25 void
26 fsstats_StartOp(struct fsstats *stats, int index)
27 {
28     stats->index = index;
29     stats->opP = &(afs_FullPerfStats.det.rpcOpTimes[index]);
30     FS_LOCK;
31     (stats->opP->numOps)++;
32     FS_UNLOCK;
33     FT_GetTimeOfDay(&stats->opStartTime, NULL);
34 }
35
36 void
37 fsstats_FinishOp(struct fsstats *stats, int code)
38 {
39     struct timeval opStopTime, elapsedTime;
40
41     FT_GetTimeOfDay(&opStopTime, NULL);
42     if (code == 0) {
43         FS_LOCK;
44         (stats->opP->numSuccesses)++;
45         fs_stats_GetDiff(elapsedTime, stats->opStartTime, opStopTime);
46         fs_stats_AddTo((stats->opP->sumTime), elapsedTime);
47         fs_stats_SquareAddTo((stats->opP->sqrTime), elapsedTime);
48         if (fs_stats_TimeLessThan(elapsedTime, (stats->opP->minTime))) {
49             fs_stats_TimeAssign((stats->opP->minTime), elapsedTime);
50         }
51         if (fs_stats_TimeGreaterThan(elapsedTime, (stats->opP->maxTime))) {
52             fs_stats_TimeAssign((stats->opP->maxTime), elapsedTime);
53         }
54         FS_UNLOCK;
55     }
56 }
57
58 void
59 fsstats_StartXfer(struct fsstats *stats)
60 {
61     FT_GetTimeOfDay(&stats->xferStartTime, NULL);
62     stats->xferP = &(afs_FullPerfStats.det.xferOpTimes[stats->index]);
63 }
64
65 void
66 fsstats_FinishXfer(struct fsstats *stats, int code,
67                    afs_sfsize_t bytesToXfer, afs_sfsize_t bytesXferred,
68                    int *remainder)
69 {
70     struct timeval xferStopTime;
71     struct timeval elapsedTime;
72
73     /*
74      * At this point, the data transfer is done, for good or ill.  Remember
75      * when the transfer ended, bump the number of successes/failures, and
76      * integrate the transfer size and elapsed time into the stats.  If the
77      * operation failed, we jump to the appropriate point.
78      */
79     FT_GetTimeOfDay(&xferStopTime, 0);
80     FS_LOCK;
81     (stats->xferP->numXfers)++;
82     if (code == 0) {
83         (stats->xferP->numSuccesses)++;
84
85         /*
86          * Bump the xfer sum by the number of bytes actually sent, NOT the
87          * target number.
88          */
89         *remainder += bytesXferred;
90         (stats->xferP->sumBytes) += (*remainder >> 10);
91         *remainder &= 0x3FF;
92         if (bytesXferred < stats->xferP->minBytes)
93             stats->xferP->minBytes = bytesXferred;
94         if (bytesXferred > stats->xferP->maxBytes)
95             stats->xferP->maxBytes = bytesXferred;
96
97         /*
98          * Tally the size of the object.  Note: we tally the actual size,
99          * NOT the number of bytes that made it out over the wire.
100          */
101         if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET0)
102             (stats->xferP->count[0])++;
103         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET1)
104             (stats->xferP->count[1])++;
105         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET2)
106             (stats->xferP->count[2])++;
107         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET3)
108             (stats->xferP->count[3])++;
109         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET4)
110             (stats->xferP->count[4])++;
111         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET5)
112             (stats->xferP->count[5])++;
113         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET6)
114             (stats->xferP->count[6])++;
115         else if (bytesToXfer <= FS_STATS_MAXBYTES_BUCKET7)
116             (stats->xferP->count[7])++;
117         else
118             (stats->xferP->count[8])++;
119
120         fs_stats_GetDiff(elapsedTime, stats->xferStartTime, xferStopTime);
121         fs_stats_AddTo((stats->xferP->sumTime), elapsedTime);
122         fs_stats_SquareAddTo((stats->xferP->sqrTime), elapsedTime);
123         if (fs_stats_TimeLessThan(elapsedTime, (stats->xferP->minTime))) {
124             fs_stats_TimeAssign((stats->xferP->minTime), elapsedTime);
125         }
126         if (fs_stats_TimeGreaterThan(elapsedTime, (stats->xferP->maxTime))) {
127             fs_stats_TimeAssign((stats->xferP->maxTime), elapsedTime);
128         }
129     }
130     FS_UNLOCK;
131 }
132
133 #else
134
135 void
136 fsstats_StartOp(struct fsstats *stats, int index)
137 {
138     return;
139 }
140
141 void
142 fsstats_FinishOp(struct fsstats *stats, int code)
143 {
144     return;
145 }
146
147 void
148 fsstats_StartXfer(struct fsstats *stats)
149 {
150     return;
151 }
152
153 void
154 fsstats_FinishXfer(struct fsstats *stats, int code,
155                    afs_sfsize_t bytesToXfer, afs_sfsize_t bytesXferred,
156                    int *remainder)
157 {
158     return;
159 }
160
161
162
163
164 #endif