EnvironmentStats


1   /*-
2    * See the file LICENSE for redistribution information.
3    *
4    * Copyright (c) 2002,2006 Oracle.  All rights reserved.
5    *
6    * $Id: EnvironmentStats.java,v 1.43 2006/10/30 21:14:12 bostic Exp $
7    */
8   
9   package com.sleepycat.je;
10  
11  import java.io.Serializable  ;
12  
13  import com.sleepycat.je.utilint.DbLsn;
14  
15  /**
16   * Javadoc for this public class is generated
17   * via the doc templates in the doc_src directory.
18   */
19  public class EnvironmentStats implements Serializable   {
20      /* INCompressor */
21  
22      /**
23       * The number of bins encountered by the INCompressor that were split
24       * between the time they were put on the compressor queue and when
25       * the compressor ran.
26       */
27      private int splitBins;
28  
29      /**
30       * The number of bins encountered by the INCompressor that had their
31       * database closed between the time they were put on the
32       * compressor queue and when the compressor ran.
33       */
34      private int dbClosedBins;
35  
36      /**
37       * The number of bins encountered by the INCompressor that had cursors
38       * referring to them when the compressor ran.
39       */
40      private int cursorsBins;
41  
42      /**
43       * The number of bins encountered by the INCompressor that were
44       * not actually empty when the compressor ran.
45       */
46      private int nonEmptyBins;
47  
48      /**
49       * The number of bins that were successfully processed by the IN
50       * Compressor.
51       */
52      private int processedBins;
53  
54      /**
55       * The number of entries in the INCompressor queue when the getStats()
56       * call was made.
57       */
58      private int inCompQueueSize;
59  
60      /* Evictor */
61  
62      /**
63       * The number of passes made to the evictor.
64       */
65      private int nEvictPasses;
66  
67      /**
68       * The accumulated number of nodes selected to evict.
69       */
70      private long nNodesSelected;
71  
72      /**
73       * The accumulated number of nodes scanned in order to select the
74       * eviction set.
75       */
76      private long nNodesScanned;
77  
78      /**
79       * The accumulated number of nodes evicted.
80       */
81      private long nNodesExplicitlyEvicted;
82  
83      /**
84       * The number of BINs stripped by the evictor.
85       */
86      private long nBINsStripped;
87  
88      /**
89       * The number of bytes we need to evict in order to get under budget.
90       */
91      private long requiredEvictBytes;
92  
93      /* Checkpointer */
94  
95      /**
96       * The total number of checkpoints run so far.
97       */
98      private int nCheckpoints;
99  
100     /**
101      * The Id of the last checkpoint.
102      */
103     private long lastCheckpointId;
104 
105     /**
106      * The accumulated number of full INs flushed to the log.
107      */
108     private int nFullINFlush;
109 
110     /**
111      * The accumulated number of full BINs flushed to the log.
112      */
113     private int nFullBINFlush;
114 
115     /**
116      * The accumulated number of Delta INs flushed to the log.
117      */
118     private int nDeltaINFlush;
119 
120     /**
121      * The location in the log of the last checkpoint start.
122      */
123     private long lastCheckpointStart;
124 
125     /**
126      * The location in the log of the last checkpoint end.
127      */
128     private long lastCheckpointEnd;
129 
130     /* Cleaner */
131 
132     /** The number of files to be cleaned to reach the target utilization. */
133     private int cleanerBacklog;
134 
135     /** The number of cleaner runs this session. */
136     private int nCleanerRuns;
137 
138     /** The number of cleaner file deletions this session. */
139     private int nCleanerDeletions;
140 
141     /**
142      * The accumulated number of INs obsolete.
143      */
144     private int nINsObsolete;
145 
146     /**
147      * The accumulated number of INs cleaned.
148      */
149     private int nINsCleaned;
150 
151     /**
152      * The accumulated number of INs that were not found in the tree anymore
153      * (deleted).
154      */
155     private int nINsDead;
156 
157     /**
158      * The accumulated number of INs migrated.
159      */
160     private int nINsMigrated;
161 
162     /**
163      * The accumulated number of LNs obsolete.
164      */
165     private int nLNsObsolete;
166 
167     /**
168      * The accumulated number of LNs cleaned.
169      */
170     private int nLNsCleaned;
171 
172     /**
173      * The accumulated number of LNs that were not found in the tree anymore
174      * (deleted).
175      */
176     private int nLNsDead;
177 
178     /**
179      * The accumulated number of LNs encountered that were locked.
180      */
181     private int nLNsLocked;
182 
183     /**
184      * The accumulated number of LNs encountered that were migrated forward
185      * in the log.
186      */
187     private int nLNsMigrated;
188 
189     /**
190      * The accumulated number of LNs that were marked for migration during
191      * cleaning.
192      */
193     private int nLNsMarked;
194 
195     /**
196      * The accumulated number of LNs processed without a tree lookup.
197      */
198     private int nLNQueueHits;
199 
200     /**
201      * The accumulated number of LNs processed because they were previously
202      * locked.
203      */
204     private int nPendingLNsProcessed;
205 
206     /**
207      * The accumulated number of LNs processed because they were previously
208      * marked for migration.
209      */
210     private int nMarkedLNsProcessed;
211 
212     /**
213      * The accumulated number of LNs processed because they are soon to be
214      * cleaned.
215      */
216     private int nToBeCleanedLNsProcessed;
217 
218     /**
219      * The accumulated number of LNs processed because they qualify for
220      * clustering.
221      */
222     private int nClusterLNsProcessed;
223 
224     /**
225      * The accumulated number of pending LNs that could not be locked for
226      * migration because of a long duration application lock.
227      */
228     private int nPendingLNsLocked;
229 
230     /**
231      * The accumulated number of log entries read by the cleaner.
232      */
233     private int nCleanerEntriesRead;
234 
235     /*
236      * Cache
237      */
238     private long cacheDataBytes; // part of cache consumed by data, in bytes
239     private long nNotResident;   // had to be instantiated from an LSN
240     private long nCacheMiss;     // had to retrieve from disk
241     private int  nLogBuffers;    // number of existing log buffers
242     private long bufferBytes;    // cache consumed by the log buffers, 
243                                  // in bytes
244 
245     /*
246      * Log activity
247      */
248     private long nFSyncs;   // Number of fsyncs issued. May be less than
249                               // nFSyncRequests because of group commit
250     private long nFSyncRequests; // Number of fsyncs requested. 
251     private long nFSyncTimeouts; // Number of group fsync requests that
252                                    // turned into singleton fsyncs.
253     /* 
254      * Number of reads which had to be repeated when faulting in an
255      * object from disk because the read chunk size controlled by
256      * je.log.faultReadSize is too small.
257      */
258     private long nRepeatFaultReads; 
259 
260     /* 
261      * Number of times we have to use the temporary marshalling buffer to
262      * write to the log.
263      */
264     private long nTempBufferWrites;
265 
266     /* 
267      * Number of times we try to read a log entry larger than the read
268      * buffer size and can't grow the log buffer to accomodate the large
269      * object. This happens during scans of the log during activities like
270      * environment open or log cleaning. Implies that the the read
271      * chunk size controlled by je.log.iteratorReadSize is too small.
272      */
273     private long nRepeatIteratorReads;
274     
275     /**
276      * Internal use only.
277      */
278     public EnvironmentStats() {
279         reset();
280     }
281 
282     /**
283      * Resets all stats.
284      */
285     private void reset() {
286         // InCompressor
287         splitBins = 0;
288         dbClosedBins = 0;
289         cursorsBins = 0;
290         nonEmptyBins = 0;
291         processedBins = 0;
292         inCompQueueSize = 0;
293 
294         // Evictor
295         nEvictPasses = 0;
296         nNodesSelected = 0;
297         nNodesScanned = 0;
298         nNodesExplicitlyEvicted = 0;
299         nBINsStripped = 0;
300         requiredEvictBytes = 0;
301 
302         // Checkpointer
303         nCheckpoints = 0;
304         lastCheckpointId = 0;
305         nFullINFlush = 0;
306         nFullBINFlush = 0;
307         nDeltaINFlush = 0;
308         lastCheckpointStart = DbLsn.NULL_LSN;
309         lastCheckpointEnd = DbLsn.NULL_LSN;
310 
311         // Cleaner
312         cleanerBacklog = 0;
313         nCleanerRuns = 0;
314         nCleanerDeletions = 0;
315         nINsObsolete = 0;
316         nINsCleaned = 0;
317         nINsDead = 0;
318         nINsMigrated = 0;
319         nLNsObsolete = 0;
320         nLNsCleaned = 0;
321         nLNsDead = 0;
322         nLNsLocked = 0;
323         nLNsMigrated = 0;
324         nLNsMarked = 0;
325         nLNQueueHits = 0;
326         nPendingLNsProcessed = 0;
327         nMarkedLNsProcessed = 0;
328         nToBeCleanedLNsProcessed = 0;
329         nClusterLNsProcessed = 0;
330         nPendingLNsLocked = 0;
331         nCleanerEntriesRead = 0;
332 
333         // Cache
334         cacheDataBytes = 0;
335         nNotResident = 0;
336         nCacheMiss = 0;
337         nLogBuffers = 0;
338         bufferBytes = 0;
339 
340         // Log
341         nFSyncs = 0;
342         nFSyncRequests = 0;
343         nFSyncTimeouts = 0;
344         nRepeatFaultReads = 0;
345     nTempBufferWrites = 0;
346         nRepeatIteratorReads = 0;
347     }
348 
349     /**
350      * Javadoc for this public method is generated via
351      * the doc templates in the doc_src directory.
352      */
353     public long getBufferBytes() {
354         return bufferBytes;
355     }
356 
357     /**
358      * Javadoc for this public method is generated via
359      * the doc templates in the doc_src directory.
360      */
361     public int getCursorsBins() {
362         return cursorsBins;
363     }
364 
365     /**
366      * Javadoc for this public method is generated via
367      * the doc templates in the doc_src directory.
368      */
369     public int getDbClosedBins() {
370         return dbClosedBins;
371     }
372 
373     /**
374      * Javadoc for this public method is generated via
375      * the doc templates in the doc_src directory.
376      */
377     public int getInCompQueueSize() {
378         return inCompQueueSize;
379     }
380 
381     /**
382      * Javadoc for this public method is generated via
383      * the doc templates in the doc_src directory.
384      */
385     public long getLastCheckpointId() {
386         return lastCheckpointId;
387     }
388 
389     /**
390      * Javadoc for this public method is generated via
391      * the doc templates in the doc_src directory.
392      */
393     public long getNCacheMiss() {
394         return nCacheMiss;
395     }
396 
397     /**
398      * Javadoc for this public method is generated via
399      * the doc templates in the doc_src directory.
400      */
401     public int getNCheckpoints() {
402         return nCheckpoints;
403     }
404 
405     /**
406      * Javadoc for this public method is generated via
407      * the doc templates in the doc_src directory.
408      */
409     public int getCleanerBacklog() {
410         return cleanerBacklog;
411     }
412 
413     /**
414      * Javadoc for this public method is generated via
415      * the doc templates in the doc_src directory.
416      */
417     public int getNCleanerRuns() {
418         return nCleanerRuns;
419     }
420 
421     /**
422      * Javadoc for this public method is generated via
423      * the doc templates in the doc_src directory.
424      */
425     public int getNCleanerDeletions() {
426         return nCleanerDeletions;
427     }
428 
429     /**
430      * Javadoc for this public method is generated via
431      * the doc templates in the doc_src directory.
432      */
433     public int getNDeltaINFlush() {
434         return nDeltaINFlush;
435     }
436 
437     /**
438      * Javadoc for this public method is generated via
439      * the doc templates in the doc_src directory.
440      */
441     public long getLastCheckpointEnd() {
442         return lastCheckpointEnd;
443     }
444 
445     /**
446      * Javadoc for this public method is generated via
447      * the doc templates in the doc_src directory.
448      */
449     public long getLastCheckpointStart() {
450         return lastCheckpointStart;
451     }
452 
453     /**
454      * Javadoc for this public method is generated via
455      * the doc templates in the doc_src directory.
456      */
457     public int getNCleanerEntriesRead() {
458         return nCleanerEntriesRead;
459     }
460 
461     /**
462      * Javadoc for this public method is generated via
463      * the doc templates in the doc_src directory.
464      */
465     public int getNEvictPasses() {
466         return nEvictPasses;
467     }
468 
469     /**
470      * Javadoc for this public method is generated via
471      * the doc templates in the doc_src directory.
472      */
473     public long getNFSyncs() {
474         return nFSyncs;
475     }
476 
477     /**
478      * Javadoc for this public method is generated via
479      * the doc templates in the doc_src directory.
480      */
481     public long getNFSyncRequests() {
482         return nFSyncRequests;
483     }
484 
485     /**
486      * Javadoc for this public method is generated via
487      * the doc templates in the doc_src directory.
488      */
489     public long getNFSyncTimeouts() {
490         return nFSyncTimeouts;
491     }
492 
493     /**
494      * Javadoc for this public method is generated via
495      * the doc templates in the doc_src directory.
496      */
497     public int getNFullINFlush() {
498         return nFullINFlush;
499     }
500 
501     /**
502      * Javadoc for this public method is generated via
503      * the doc templates in the doc_src directory.
504      */
505     public int getNFullBINFlush() {
506         return nFullBINFlush;
507     }
508 
509     /**
510      * Javadoc for this public method is generated via
511      * the doc templates in the doc_src directory.
512      */
513     public int getNINsObsolete() {
514         return nINsObsolete;
515     }
516 
517     /**
518      * Javadoc for this public method is generated via
519      * the doc templates in the doc_src directory.
520      */
521     public int getNINsCleaned() {
522         return nINsCleaned;
523     }
524 
525     /**
526      * Javadoc for this public method is generated via
527      * the doc templates in the doc_src directory.
528      */
529     public int getNINsDead() {
530         return nINsDead;
531     }
532 
533     /**
534      * Javadoc for this public method is generated via
535      * the doc templates in the doc_src directory.
536      */
537     public int getNINsMigrated() {
538         return nINsMigrated;
539     }
540 
541     /**
542      * Javadoc for this public method is generated via
543      * the doc templates in the doc_src directory.
544      */
545     public int getNLNsObsolete() {
546         return nLNsObsolete;
547     }
548 
549     /**
550      * Javadoc for this public method is generated via
551      * the doc templates in the doc_src directory.
552      */
553     public int getNLNsCleaned() {
554         return nLNsCleaned;
555     }
556 
557     /**
558      * Javadoc for this public method is generated via
559      * the doc templates in the doc_src directory.
560      */
561     public int getNLNsDead() {
562         return nLNsDead;
563     }
564 
565     /**
566      * Javadoc for this public method is generated via
567      * the doc templates in the doc_src directory.
568      */
569     public int getNLNsLocked() {
570         return nLNsLocked;
571     }
572 
573     /**
574      * Javadoc for this public method is generated via
575      * the doc templates in the doc_src directory.
576      */
577     public int getNLNsMigrated() {
578         return nLNsMigrated;
579     }
580 
581     /**
582      * Javadoc for this public method is generated via
583      * the doc templates in the doc_src directory.
584      */
585     public int getNLNsMarked() {
586         return nLNsMarked;
587     }
588 
589     /**
590      * Javadoc for this public method is generated via
591      * the doc templates in the doc_src directory.
592      */
593     public int getNLNQueueHits() {
594         return nLNQueueHits;
595     }
596 
597     /**
598      * Javadoc for this public method is generated via
599      * the doc templates in the doc_src directory.
600      */
601     public int getNPendingLNsProcessed() {
602         return nPendingLNsProcessed;
603     }
604 
605     /**
606      * Javadoc for this public method is generated via
607      * the doc templates in the doc_src directory.
608      */
609     public int getNMarkedLNsProcessed() {
610         return nMarkedLNsProcessed;
611     }
612 
613     /**
614      * Javadoc for this public method is generated via
615      * the doc templates in the doc_src directory.
616      */
617     public int getNToBeCleanedLNsProcessed() {
618         return nToBeCleanedLNsProcessed;
619     }
620 
621     /**
622      * Javadoc for this public method is generated via
623      * the doc templates in the doc_src directory.
624      */
625     public int getNClusterLNsProcessed() {
626         return nClusterLNsProcessed;
627     }
628 
629     /**
630      * Javadoc for this public method is generated via
631      * the doc templates in the doc_src directory.
632      */
633     public int getNPendingLNsLocked() {
634         return nPendingLNsLocked;
635     }
636 
637     /**
638      * Javadoc for this public method is generated via
639      * the doc templates in the doc_src directory.
640      */
641     public int getNLogBuffers() {
642         return nLogBuffers;
643     }
644 
645     /**
646      * Javadoc for this public method is generated via
647      * the doc templates in the doc_src directory.
648      */
649     public long getNNodesExplicitlyEvicted() {
650         return nNodesExplicitlyEvicted;
651     }
652 
653     /**
654      * Javadoc for this public method is generated via
655      * the doc templates in the doc_src directory.
656      */
657     public long getNBINsStripped() {
658         return nBINsStripped;
659     }
660 
661     /**
662      * Javadoc for this public method is generated via
663      * the doc templates in the doc_src directory.
664      */
665     public long getRequiredEvictBytes() {
666         return requiredEvictBytes;
667     }
668 
669     /**
670      * Javadoc for this public method is generated via
671      * the doc templates in the doc_src directory.
672      */
673     public long getNNodesScanned() {
674         return nNodesScanned;
675     }
676 
677     /**
678      * Javadoc for this public method is generated via
679      * the doc templates in the doc_src directory.
680      */
681     public long getNNodesSelected() {
682         return nNodesSelected;
683     }
684 
685     /**
686      * Javadoc for this public method is generated via
687      * the doc templates in the doc_src directory.
688      */
689     public long getCacheTotalBytes() {
690         return cacheDataBytes + bufferBytes;
691     }
692 
693     /**
694      * Javadoc for this public method is generated via
695      * the doc templates in the doc_src directory.
696      */
697     public long getCacheDataBytes() {
698         return cacheDataBytes;
699     }
700 
701     /**
702      * Javadoc for this public method is generated via
703      * the doc templates in the doc_src directory.
704      */
705     public long getNNotResident() {
706         return nNotResident;
707     }
708 
709     /**
710      * Javadoc for this public method is generated via
711      * the doc templates in the doc_src directory.
712      */
713     public int getNonEmptyBins() {
714         return nonEmptyBins;
715     }
716 
717     /**
718      * Javadoc for this public method is generated via
719      * the doc templates in the doc_src directory.
720      */
721     public int getProcessedBins() {
722         return processedBins;
723     }
724 
725     /**
726      * Javadoc for this public method is generated via
727      * the doc templates in the doc_src directory.
728      */
729     public long getNRepeatFaultReads() {
730         return nRepeatFaultReads;
731     }
732 
733     /**
734      * Javadoc for this public method is generated via
735      * the doc templates in the doc_src directory.
736      */
737     public long getNTempBufferWrites() {
738         return nTempBufferWrites;
739     }
740 
741     /**
742      * Javadoc for this public method is generated via
743      * the doc templates in the doc_src directory.
744      */
745     public long getNRepeatIteratorReads() {
746         return nRepeatIteratorReads;
747     }
748 
749     /**
750      * Javadoc for this public method is generated via
751      * the doc templates in the doc_src directory.
752      */
753     public int getSplitBins() {
754         return splitBins;
755     }
756 
757     /**
758      * Internal use only.
759      */
760     public void setCacheDataBytes(long cacheDataBytes) {
761         this.cacheDataBytes = cacheDataBytes;
762     }
763 
764     /**
765      * Internal use only.
766      */
767     public void setNNotResident(long nNotResident) {
768         this.nNotResident = nNotResident;
769     }
770 
771     /**
772      * Internal use only.
773      */
774     public void setNCacheMiss(long nCacheMiss) {
775         this.nCacheMiss = nCacheMiss;
776     }
777 
778     /**
779      * Internal use only.
780      */
781     public void setNLogBuffers(int nLogBuffers) {
782         this.nLogBuffers = nLogBuffers;
783     }
784 
785     /**
786      * Internal use only.
787      */
788     public void setBufferBytes(long bufferBytes) {
789         this.bufferBytes = bufferBytes;
790     }
791 
792     /**
793      * Internal use only.
794      */
795     public void setCursorsBins(int val) {
796         cursorsBins = val;
797     }
798 
799     /**
800      * Internal use only.
801      */
802     public void setDbClosedBins(int val) {
803         dbClosedBins = val;
804     }
805 
806     /**
807      * Internal use only.
808      */
809     public void setInCompQueueSize(int val) {
810         inCompQueueSize = val;
811     }
812 
813     /**
814      * Internal use only.
815      */
816     public void setLastCheckpointId(long l) {
817         lastCheckpointId = l;
818     }
819 
820     /**
821      * Internal use only.
822      */
823     public void setNCheckpoints(int val) {
824         nCheckpoints = val;
825     }
826 
827     /**
828      * Internal use only.
829      */
830     public void setCleanerBacklog(int val) {
831         cleanerBacklog = val;
832     }
833 
834     /**
835      * Internal use only.
836      */
837     public void setNCleanerRuns(int val) {
838         nCleanerRuns = val;
839     }
840 
841     /**
842      * Internal use only.
843      */
844     public void setNCleanerDeletions(int val) {
845         nCleanerDeletions = val;
846     }
847 
848     /**
849      * Internal use only.
850      */
851     public void setNDeltaINFlush(int val) {
852         nDeltaINFlush = val;
853     }
854 
855     /**
856      * Internal use only.
857      */
858     public void setLastCheckpointEnd(long lsn) {
859         lastCheckpointEnd = lsn;
860     }
861 
862     /**
863      * Internal use only.
864      */
865     public void setLastCheckpointStart(long lsn) {
866         lastCheckpointStart = lsn;
867     }
868 
869     /**
870      * Internal use only.
871      */
872     public void setNCleanerEntriesRead(int val) {
873         nCleanerEntriesRead = val;
874     }
875 
876     /**
877      * Internal use only.
878      */
879     public void setNEvictPasses(int val) {
880         nEvictPasses = val;
881     }
882 
883     /**
884      * Internal use only.
885      */
886     public void setNFSyncs(long val) {
887         nFSyncs = val;
888     }
889 
890     /**
891      * Internal use only.
892      */
893     public void setNFSyncRequests(long val) {
894         nFSyncRequests = val;
895     }
896 
897     /**
898      * Internal use only.
899      */
900     public void setNFSyncTimeouts(long val) {
901         nFSyncTimeouts = val;
902     }
903 
904     /**
905      * Internal use only.
906      */
907     public void setNFullINFlush(int val) {
908         nFullINFlush = val;
909     }
910 
911     /**
912      * Internal use only.
913      */
914     public void setNFullBINFlush(int val) {
915         nFullBINFlush = val;
916     }
917 
918     /**
919      * Internal use only.
920      */
921     public void setNINsObsolete(int val) {
922         nINsObsolete = val;
923     }
924 
925     /**
926      * Internal use only.
927      */
928     public void setNINsCleaned(int val) {
929         nINsCleaned = val;
930     }
931 
932     /**
933      * Internal use only.
934      */
935     public void setNINsDead(int val) {
936         nINsDead = val;
937     }
938 
939     /**
940      * Internal use only.
941      */
942     public void setNINsMigrated(int val) {
943         nINsMigrated = val;
944     }
945 
946     /**
947      * Internal use only.
948      */
949     public void setNLNsObsolete(int val) {
950         nLNsObsolete = val;
951     }
952 
953     /**
954      * Internal use only.
955      */
956     public void setNLNsCleaned(int val) {
957         nLNsCleaned = val;
958     }
959 
960     /**
961      * Internal use only.
962      */
963     public void setNLNsDead(int val) {
964         nLNsDead = val;
965     }
966 
967     /**
968      * Internal use only.
969      */
970     public void setNLNsLocked(int val) {
971         nLNsLocked = val;
972     }
973 
974     /**
975      * Internal use only.
976      */
977     public void setNLNsMigrated(int val) {
978         nLNsMigrated = val;
979     }
980 
981     /**
982      * Internal use only.
983      */
984     public void setNLNsMarked(int val) {
985         nLNsMarked = val;
986     }
987 
988     /**
989      * Internal use only.
990      */
991     public void setNLNQueueHits(int val) {
992         nLNQueueHits = val;
993     }
994 
995     /**
996      * Internal use only.
997      */
998     public void setNPendingLNsProcessed(int val) {
999         nPendingLNsProcessed = val;
1000    }
1001
1002    /**
1003     * Internal use only.
1004     */
1005    public void setNMarkedLNsProcessed(int val) {
1006        nMarkedLNsProcessed = val;
1007    }
1008
1009    /**
1010     * Internal use only.
1011     */
1012    public void setNToBeCleanedLNsProcessed(int val) {
1013        nToBeCleanedLNsProcessed = val;
1014    }
1015
1016    /**
1017     * Internal use only.
1018     */
1019    public void setNClusterLNsProcessed(int val) {
1020        nClusterLNsProcessed = val;
1021    }
1022
1023    /**
1024     * Internal use only.
1025     */
1026    public void setNPendingLNsLocked(int val) {
1027        nPendingLNsLocked = val;
1028    }
1029
1030    /**
1031     * Internal use only.
1032     */
1033    public void setNNodesExplicitlyEvicted(long l) {
1034        nNodesExplicitlyEvicted = l;
1035    }
1036
1037    /**
1038     * Internal use only.
1039     */
1040    public void setRequiredEvictBytes(long l) {
1041        requiredEvictBytes = l;
1042    }
1043
1044    /**
1045     * Internal use only.
1046     */
1047    public void setNBINsStripped(long l) {
1048        nBINsStripped = l;
1049    }
1050
1051    /**
1052     * Internal use only.
1053     */
1054    public void setNNodesScanned(long l) {
1055        nNodesScanned = l;
1056    }
1057
1058    /**
1059     * Internal use only.
1060     */
1061    public void setNNodesSelected(long l) {
1062        nNodesSelected = l;
1063    }
1064
1065    /**
1066     * Internal use only.
1067     */
1068    public void setNonEmptyBins(int val) {
1069        nonEmptyBins = val;
1070    }
1071
1072    /**
1073     * Internal use only.
1074     */
1075    public void setProcessedBins(int val) {
1076        processedBins = val;
1077    }
1078
1079    /**
1080     * Internal use only.
1081     */
1082    public void setNRepeatFaultReads(long val) {
1083        nRepeatFaultReads = val;
1084    }
1085
1086    /**
1087     * Internal use only.
1088     */
1089    public void setNTempBufferWrites(long val) {
1090        nTempBufferWrites = val;
1091    }
1092
1093    /**
1094     * Internal use only.
1095     */
1096    public void setNRepeatIteratorReads(long val) {
1097        nRepeatIteratorReads = val;
1098    }
1099
1100    /**
1101     * Internal use only.
1102     */
1103    public void setSplitBins(int val) {
1104        splitBins = val;
1105    }
1106
1107    /**
1108     * Javadoc for this public method is generated via
1109     * the doc templates in the doc_src directory.
1110     */
1111    public String   toString() {
1112        StringBuffer   sb = new StringBuffer  ();
1113        sb.append("splitBins=").append(splitBins).append('\n');
1114        sb.append("dbClosedBins=").append(dbClosedBins).append('\n');
1115        sb.append("cursorsBins=").append(cursorsBins).append('\n');
1116        sb.append("nonEmptyBins=").append(nonEmptyBins).append('\n');
1117        sb.append("processedBins=").append(processedBins).append('\n');
1118        sb.append("inCompQueueSize=").append(inCompQueueSize).append('\n');
1119
1120        // Evictor
1121        sb.append("nEvictPasses=").append(nEvictPasses).append('\n');
1122        sb.append("nNodesSelected=").append(nNodesSelected).append('\n');
1123        sb.append("nNodesScanned=").append(nNodesScanned).append('\n');
1124        sb.append("nNodesExplicitlyEvicted=").
1125           append(nNodesExplicitlyEvicted).append('\n');
1126        sb.append("nBINsStripped=").append(nBINsStripped).append('\n');
1127        sb.append("requiredEvictBytes=").append(requiredEvictBytes).
1128            append('\n');
1129
1130        // Checkpointer
1131        sb.append("nCheckpoints=").append(nCheckpoints).append('\n');
1132        sb.append("lastCheckpointId=").append(lastCheckpointId).append('\n');
1133        sb.append("nFullINFlush=").append(nFullINFlush).append('\n');
1134        sb.append("nFullBINFlush=").append(nFullBINFlush).append('\n');
1135        sb.append("nDeltaINFlush=").append(nDeltaINFlush).append('\n');
1136        sb.append("lastCheckpointStart=").
1137           append(DbLsn.getNoFormatString(lastCheckpointStart)).append('\n');
1138        sb.append("lastCheckpointEnd=").
1139           append(DbLsn.getNoFormatString(lastCheckpointEnd)).append('\n');
1140
1141        // Cleaner
1142        sb.append("cleanerBacklog=").append(cleanerBacklog).append('\n');
1143        sb.append("nCleanerRuns=").append(nCleanerRuns).append('\n');
1144        sb.append("nCleanerDeletions=").append(nCleanerDeletions).append('\n');
1145        sb.append("nINsObsolete=").append(nINsObsolete).append('\n');
1146        sb.append("nINsCleaned=").append(nINsCleaned).append('\n');
1147        sb.append("nINsDead=").append(nINsDead).append('\n');
1148        sb.append("nINsMigrated=").append(nINsMigrated).append('\n');
1149        sb.append("nLNsObsolete=").append(nLNsObsolete).append('\n');
1150        sb.append("nLNsCleaned=").append(nLNsCleaned).append('\n');
1151        sb.append("nLNsDead=").append(nLNsDead).append('\n');
1152        sb.append("nLNsLocked=").append(nLNsLocked).append('\n');
1153        sb.append("nLNsMigrated=").append(nLNsMigrated).append('\n');
1154        sb.append("nLNsMarked=").append(nLNsMarked).append('\n');
1155        sb.append("nLNQueueHits=").
1156            append(nLNQueueHits).append('\n');
1157        sb.append("nPendingLNsProcessed=").
1158            append(nPendingLNsProcessed).append('\n');
1159        sb.append("nMarkedLNsProcessed=").
1160            append(nMarkedLNsProcessed).append('\n');
1161        sb.append("nToBeCleanedLNsProcessed=").
1162            append(nToBeCleanedLNsProcessed).append('\n');
1163        sb.append("nClusterLNsProcessed=").
1164            append(nClusterLNsProcessed).append('\n');
1165        sb.append("nPendingLNsLocked=").
1166            append(nPendingLNsLocked).append('\n');
1167        sb.append("nCleanerEntriesRead=").
1168           append(nCleanerEntriesRead).append('\n');
1169
1170        // Cache
1171        sb.append("nNotResident=").append(nNotResident).append('\n');
1172        sb.append("nCacheMiss=").append(nCacheMiss).append('\n');
1173        sb.append("nLogBuffers=").append(nLogBuffers).append('\n');
1174        sb.append("bufferBytes=").append(bufferBytes).append('\n');
1175        sb.append("cacheDataBytes=").append(cacheDataBytes).append('\n');
1176        sb.append("cacheTotalBytes=").append(getCacheTotalBytes()).
1177            append('\n');
1178        sb.append("nFSyncs=").append(nFSyncs).append('\n');
1179        sb.append("nFSyncRequests=").append(nFSyncRequests).append('\n');
1180        sb.append("nFSyncTimeouts=").append(nFSyncTimeouts).append('\n');
1181        sb.append("nRepeatFaultReads=").append(nRepeatFaultReads).append('\n');
1182        sb.append("nTempBufferWrite=").append(nTempBufferWrites).append('\n');
1183        sb.append("nRepeatIteratorReads=").
1184            append(nRepeatIteratorReads).append('\n');
1185
1186        return sb.toString();
1187    }
1188}
1189
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Free Books Free Magazines
Popular Tags