home | career | drupal | java | mac | mysql | perl | scala | uml | unix  

Lucene example source code file (TaskStats.java)

This example Lucene source code file (TaskStats.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Lucene tags/keywords

cloneable, clonenotsupportedexception, illegalstateexception, illegalstateexception, object, override, override, perftask, perftask, string, stringbuilder, taskstats, taskstats

The Lucene TaskStats.java source code

package org.apache.lucene.benchmark.byTask.stats;

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import org.apache.lucene.benchmark.byTask.tasks.PerfTask;

/**
 * Statistics for a task run. 
 * <br>The same task can run more than once, but, if that task records statistics, 
 * each run would create its own TaskStats.
 */
public class TaskStats implements Cloneable {

  /** task for which data was collected */
  private PerfTask task; 

  /** round in which task run started */
  private int round;

  /** task start time */
  private long start;
  
  /** task elapsed time.  elapsed >= 0 indicates run completion! */
  private long elapsed = -1;
  
  /** max tot mem during task */
  private long maxTotMem;
  
  /** max used mem during task */
  private long maxUsedMem;
  
  /** serial run number of this task run in the perf run */
  private int taskRunNum;
  
  /** number of other tasks that started to run while this task was still running */ 
  private int numParallelTasks;
  
  /** number of work items done by this task.
   * For indexing that can be number of docs added.
   * For warming that can be number of scanned items, etc. 
   * For repeating tasks, this is a sum over repetitions.
   */
  private int count;

  /** Number of similar tasks aggregated into this record.   
   * Used when summing up on few runs/instances of similar tasks.
   */
  private int numRuns = 1;
  
  /**
   * Create a run data for a task that is starting now.
   * To be called from Points.
   */
  TaskStats (PerfTask task, int taskRunNum, int round) {
    this.task = task;
    this.taskRunNum = taskRunNum;
    this.round = round;
    maxTotMem = Runtime.getRuntime().totalMemory();
    maxUsedMem = maxTotMem - Runtime.getRuntime().freeMemory();
    start = System.currentTimeMillis();
  }
  
  /**
   * mark the end of a task
   */
  void markEnd (int numParallelTasks, int count) {
    elapsed = System.currentTimeMillis() - start;
    long totMem = Runtime.getRuntime().totalMemory();
    if (totMem > maxTotMem) {
      maxTotMem = totMem;
    }
    long usedMem = totMem - Runtime.getRuntime().freeMemory();
    if (usedMem > maxUsedMem) {
      maxUsedMem = usedMem;
    }
    this.numParallelTasks = numParallelTasks;
    this.count = count;
  }
  
  private int[] countsByTime;
  private long countsByTimeStepMSec;

  public void setCountsByTime(int[] counts, long msecStep) {
    countsByTime = counts;
    countsByTimeStepMSec = msecStep;
  }

  public int[] getCountsByTime() {
    return countsByTime;
  }

  public long getCountsByTimeStepMSec() {
    return countsByTimeStepMSec;
  }

  /**
   * @return the taskRunNum.
   */
  public int getTaskRunNum() {
    return taskRunNum;
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  @Override
  public String toString() {
    StringBuilder res = new StringBuilder(task.getName());
    res.append(" ");
    res.append(count);
    res.append(" ");
    res.append(elapsed);
    return res.toString();
  }

  /**
   * @return Returns the count.
   */
  public int getCount() {
    return count;
  }

  /**
   * @return elapsed time.
   */
  public long getElapsed() {
    return elapsed;
  }

  /**
   * @return Returns the maxTotMem.
   */
  public long getMaxTotMem() {
    return maxTotMem;
  }

  /**
   * @return Returns the maxUsedMem.
   */
  public long getMaxUsedMem() {
    return maxUsedMem;
  }

  /**
   * @return Returns the numParallelTasks.
   */
  public int getNumParallelTasks() {
    return numParallelTasks;
  }

  /**
   * @return Returns the task.
   */
  public PerfTask getTask() {
    return task;
  }

  /**
   * @return Returns the numRuns.
   */
  public int getNumRuns() {
    return numRuns;
  }

  /**
   * Add data from another stat, for aggregation
   * @param stat2 the added stat data.
   */
  public void add(TaskStats stat2) {
    numRuns += stat2.getNumRuns();
    elapsed += stat2.getElapsed();
    maxTotMem += stat2.getMaxTotMem();
    maxUsedMem += stat2.getMaxUsedMem();
    count += stat2.getCount();
    if (round != stat2.round) {
      round = -1; // no meaning if aggregating tasks of different round. 
    }

    if (countsByTime != null && stat2.countsByTime != null) {
      if (countsByTimeStepMSec != stat2.countsByTimeStepMSec) {
        throw new IllegalStateException("different by-time msec step");
      }
      if (countsByTime.length != stat2.countsByTime.length) {
        throw new IllegalStateException("different by-time msec count");
      }
      for(int i=0;i<stat2.countsByTime.length;i++) {
        countsByTime[i] += stat2.countsByTime[i];
      }
    }
  }

  /* (non-Javadoc)
   * @see java.lang.Object#clone()
   */
  @Override
  public Object clone() throws CloneNotSupportedException {
    TaskStats c = (TaskStats) super.clone();
    if (c.countsByTime != null) {
      c.countsByTime = c.countsByTime.clone();
    }
    return c;
  }

  /**
   * @return the round number.
   */
  public int getRound() {
    return round;
  }
  
}

Other Lucene examples (source code examples)

Here is a short list of links related to this Lucene TaskStats.java source code file:



my book on functional programming

 

new blog posts

 

Copyright 1998-2019 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.