/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.io.*;
import java.util.*;
import java.text.SimpleDateFormat;

import com.sun.solaris.service.logging.*;
import com.sun.solaris.service.pools.*;

/**
 * This class maintains history about previous decisions.  It can be
 * used to ratify that a decision made on the basis of observed behavior
 * over a limited time was historically shown to not degrade
 * performance.  The class maintains historical data in a history file.
 * The format of this data is project-private and very likely to change
 * as the implementation improves.
 */
public final class DecisionHistory implements Serializable {
	/**
	 * The number of samples which a decision will be remembered.
	 */
	public static final int DECISION_LIFETIME = 256;

	/**
	 * Map of values of historical decisions.
	 */
	private HashMap decisions = new HashMap();

	/**
	 * Map of resources to be monitored for improvement in
	 * utilization to the corresponding decision.  Maps Resources to
	 * their decision's key string.
	 */
	private transient HashMap resourcesAwaitingImprovement = new HashMap();

	/**
	 * List of decisions, in order of creation, to manage expiry.
	 */
	private transient LinkedList decisionList = new LinkedList();

	/**
	 * Constructor.
	 */
	public DecisionHistory()
	{
	}

	/**
	 * Record a decision that's been made regarding a processor.
	 * Such a decision is a (cpuid, from-pset-name, to-pset-name,
	 * (from-pset-composition), (to-pset-composition),
	 * original-utilization-class) tuple.
	 */
	public void recordProcessorMove(ComponentMove move,
	    double startingUtilization, int sampleCount) throws PoolsException
	{
		Decision decision = Decision.forMove(move, startingUtilization);
		decision.setStartingSampleCount(sampleCount);
		Object o = decisions.put(decision.getKey(), decision);
		Poold.OPT_LOG.log(Severity.DEBUG, "recorded decision (" +
		    decision + ")" + (o == null ? "" : " (displaced " + o +
		    ")"));

		/*
		 * Remember the most-recently-made decision regarding a
		 * resource until the next utilization sample is taken,
		 * so the next solve() may then reocrd the improvement.
		 * If another decision is made regarding this resource,
		 * the previous ones are forgotten, and their
		 * improvement fields are left 0.
		 */
		resourcesAwaitingImprovement.put(move.getTo(),
		    decision.getKey());
		decisionList.add(decision);
	}

	private void recordImprovementWithUtilization(Resource resource,
	    double utilization)
	{
		String decisionKey = (String)resourcesAwaitingImprovement.get(
		    resource);

		if (decisionKey != null) {
			Decision decision = (Decision)decisions.get(
			    decisionKey);
			if (decision != null) {
				decision.setImprovementWithNewUtilization(
				    utilization);
				Poold.OPT_LOG.log(Severity.DEBUG, resource +
				    " improvement measured for decision " +
				    decision.describe());
			}
		}
	}

	/**
	 * A Decision boils down to a tuple describing the resource
	 * configuration involved before and after a particular resource
	 * is moved.  We use a textual representation to describe the
	 * decision, by value, to avoid holding references to any of the
	 * actual resources involved.
	 */
	private static abstract class Decision implements Serializable {
		/**
		 * Utilization of the resource before the move was made.
		 */
		private double startingUtilization = 0.0;

		/**
		 * Improvement in utilization (-1..1) after the move was
		 * made, if the determination is made.
		 */
		private double improvement = 0.0;

		/**
		 * Number of times this decision has been reexamined.
		 */
		private int usage = 0;

		/**
		 * Monitor's sample count when the decision was made,
		 * used to expire this decision after DECISION_LIFETIME
		 * samples.
		 */
		private int startingSampleCount;

		/**
		 * Decision's creation time.
		 */
		private Date date;

		/**
		 * Returns a String key for this Decision.
		 */
		public abstract String getKey();

		/**
		 * Returns a Decision corresponding to a given Move.
		 * @return a Decision corresponding to a given Move.
		 * @throws InvalidArgumentException if there is no
		 * Decision type corresponding to the move.
		 */
		public static final Decision forMove(Move move,
		    double startingUtilization)
		{
			if (move instanceof ComponentMove)
				return (new ComponentMoveDecision(
				    (ComponentMove)move, startingUtilization));
			else
				return (null);
		}

		private Decision()
		{
			date = new Date();
		}

		/**
		 * Invoked after construction, sets the utilization
		 * corresponding to the affected resource before the move
		 * was made.
		 */
		public final void setStartingUtilization(
		    double startingUtilization)
		{
			this.startingUtilization = startingUtilization;
		}

		/**
		 * Invoked after construction, sets the sampleCount from
		 * the monitor, used to expire this decision after
		 * DECISION_LIFETIME samples.
		 */
		public void setStartingSampleCount(int sampleCount)
		{
			this.startingSampleCount = sampleCount;
		}

		/**
		 * sampleCount accessor.
		 */
		public int getStartingSampleCount()
		{
			return (startingSampleCount);
		}

		/**
		 * Stores the improvement, computed in a
		 * subclass-specific way.
		 */
		abstract public void setImprovementWithNewUtilization(
		    double newUtilization);

		/**
		 * Allow subclasses to record the improvement.
		 */
		protected void setImprovement(double improvement)
		{
			this.improvement = improvement;
		}

		/**
		 * Returns the improvement in utilization measured by
		 * the monitor after the move is made.
		 */
		public final double getImprovement()
		{
			return (improvement);
		}

		/**
		 * Returns the utilization corresponding to the affected
		 * resource before the move was made.
		 */
		public final double getStartingUtilization()
		{
			return (startingUtilization);
		}

		public abstract int hashCode();
		public abstract boolean equals(Object o);
		public abstract String toString();

		private static final long serialVersionUID = 0x7860687;

		/**
		 * Number of times this decision has been reexamined.
		 */
		public final int getUsage()
		{
			return (usage);
		}

		private final void incrementUsage()
		{
			usage++;
		}

		/**
		 * Returns the time this decision was created.
		 */
		public final Date getDate()
		{
			return date;
		}

		/**
		 * Formatter for printing creation date.
		 */
		private static SimpleDateFormat dateFormatter;

		/**
		 * Format for printing creation date.
		 */
		private final static String dateFormat = "MMM d kk:mm:ss";

		/**
		 * Returns a more comprehensive textual representation
		 * of this devision than toString().
		 */
		public final String describe()
		{
			if (dateFormatter == null)
				dateFormatter = new SimpleDateFormat(
				    dateFormat);
			return (toString() + " made at " +
			    dateFormatter.format(getDate()) +
			    " with improvement " + getImprovement() +
			    " used " + getUsage() + " times");
		}
	}

	/**
	 * A Decision affecting the transfer of one CPU between
	 * processor sets.
	 */
	private static final class ComponentMoveDecision extends Decision {
		/**
		 * The CPU Id of the involved CPU.
		 */
		private String cpuid;

		/**
		 * The name of the donating processor set.
		 */
		private String fromPsetName;

		/**
		 * The name of the receiving processor set.
		 */
		private String toPsetName;

		/**
		 * The string representation of the list of CPU IDs
		 * composing the donating set.
		 */
		private String fromPsetComposition;

		/**
		 * The string representation of the list of CPU IDs
		 * composing the receiving set.
		 */
		private String toPsetComposition;

		/**
		 * The number of CPUs in the receiving set, after the
		 * move is made.
		 */
		private int toPsetSize;

		/**
		 * A Decision-subclass-specific utilization group.
		 */
		private String utilizationClass;

		/**
		 * Constructs a ComponentMoveDecision based on the
		 * ComponentMove.
		 * @throws IllegalArgumentException if the ComponentMove
		 * can't be interpreted.
		 */
		public ComponentMoveDecision(ComponentMove move,
		    double startingUtilization) throws IllegalArgumentException
		{
			try {
				cpuid = move.getComponents().toString();
				fromPsetName = move.getFrom().toString();
				toPsetName = move.getTo().toString();
				fromPsetComposition = move.getFrom()
				    .getComponents(null).toString();
				toPsetComposition = move.getTo()
				    .getComponents(null).toString();
				toPsetSize = move.getTo().getComponents(null)
				    .size();
				utilizationClass = computeUtilizationClass(
				    startingUtilization);
				setStartingUtilization(startingUtilization);
			} catch (PoolsException pe) {
				throw(IllegalArgumentException)(
				    new IllegalArgumentException().initCause(
				    pe));
			}
		}

		public String getKey()
		{
			StringBuffer sb = new StringBuffer();

			sb.append(cpuid);
			sb.append(", ");
			sb.append(fromPsetName);
			sb.append(", ");
			sb.append(toPsetName);

			return (sb.toString());
		}

		public void setImprovementWithNewUtilization(
		    double newUtilization)
		{
			double sizeRatio = (double)(toPsetSize - 1) /
			    toPsetSize;
			double expectedUtilization = sizeRatio *
			    getStartingUtilization();

			Poold.OPT_LOG.log(Severity.DEBUG,
			    "pset improvement calculation expected " +
			    expectedUtilization + ", got " + newUtilization);
			setImprovement(newUtilization - expectedUtilization);
		}

		public int hashCode() {
			return (((((cpuid.hashCode() ^
			    fromPsetName.hashCode()) ^ toPsetName.hashCode()) ^
			    fromPsetComposition.hashCode()) ^
			    toPsetComposition.hashCode()) ^
			    utilizationClass.hashCode());
		}

		public boolean equals(Object o) {
			if (!(o instanceof ComponentMoveDecision))
				return false;
			else {
				ComponentMoveDecision cmd =
				    (ComponentMoveDecision)o;
				return (cpuid.equals(cmd.cpuid) &&
				    fromPsetName.equals(cmd.fromPsetName) &&
				    toPsetName.equals(cmd.toPsetName) &&
				    fromPsetComposition.equals(
				    cmd.fromPsetComposition) &&
				    toPsetComposition.equals(
				    cmd.toPsetComposition) &&
				    utilizationClass.equals(
				    cmd.utilizationClass));
			}
		}

		/**
		 * Returns the group that this decision's utilization
		 * falls into.  Presently, there is only one group, but
		 * ostensibly decisions will later be grouped (e.g.
		 * into control-zone-wide groups).
		 */
		private String computeUtilizationClass(
		    double startingUtilization)
		{
			return "I";
		}

		public String toString()
		{
			StringBuffer sb = new StringBuffer();

			sb.append(cpuid.toString());
			sb.append(", ");
			sb.append(fromPsetName.toString());
			sb.append(", ");
			sb.append(toPsetName.toString());
			sb.append(", ");
			sb.append(fromPsetComposition.toString());
			sb.append(", ");
			sb.append(toPsetComposition.toString());
			sb.append(", ");
			sb.append(utilizationClass.toString());

			return (sb.toString());
		}

		private static final long serialVersionUID = 0xf7860687;
	}

	/**
	 * Vetoes a Move only if there is a prior decision that showed a
	 * degradation in resource utilization.
	 */
	public boolean veto(Move m, double utilization)
	{
		Decision current = Decision.forMove(m, utilization);
		Decision past;

		if (current != null) {
			past = (Decision)decisions.get(current.getKey());
			if (past != null)
				past.incrementUsage();
			if (past != null && past.getImprovement() < 0.0) {
				Poold.OPT_LOG.log(Severity.DEBUG, m +
				    " vetoed by decision " + past.describe());
				return true;
			}
		}

		return false;
	}

	private static final long serialVersionUID = 0xf7860687;

	/**
	 * Synchronize the decision history with the persistent version.
	 */
	public static DecisionHistory loadFromFile(String path)
	    throws IOException, ClassNotFoundException
	{
		return (load(new FileInputStream(path)));
	}

	/**
	 * Synchronize the persistent decision history with the present
	 * history.
	 */
	public void syncToFile(String path) throws IOException
	{
		FileOutputStream fos = new FileOutputStream(path);
		sync(fos);
		fos.close();
	}

	/**
	 * Synchronize the decision history with the persistent version,
	 * from the given stream.
	 */
	public static DecisionHistory load(InputStream is)
	    throws IOException, ClassNotFoundException
	{
		ObjectInputStream ois = new ObjectInputStream(is);

		DecisionHistory dh = (DecisionHistory)ois.readObject();
		return (dh);
	}

	/**
	 * Serialize the persistent decision history to the given
	 * stream.
	 */
	public void sync(OutputStream os) throws IOException
	{
		new ObjectOutputStream(os).writeObject(this);
	}

	public String toString()
	{
		StringBuffer sb = new StringBuffer();

		sb.append(decisions.keySet().size() + " decisions {");
		Iterator it = decisions.keySet().iterator();
		while (it.hasNext()) {
			String dk = (String)it.next();
			Decision d = (Decision)decisions.get(dk);

			sb.append("\t(");
			sb.append(d.describe());
			sb.append(")\n");
		}
		sb.append("}");

		return (sb.toString());
	}

	/**
	 * Measures the improvement in utilization of any resource for
	 * which a decision was recently made.
	 */
	public void expireAndMeasureImprovements(Monitor mon)
	{
		/*
		 * Measure the improvement in resources involved in
		 * recent decisions.
		 */
		if (mon.isValid()) {
			for (Iterator it = resourcesAwaitingImprovement.
			    keySet().iterator(); it.hasNext(); ) {
				Resource res = (Resource)it.next();
				try {
					double utilization = mon.
					    getUtilization(res);
					recordImprovementWithUtilization(res,
					    utilization);
				} catch (StaleMonitorException sme) {
					/*
					 * We can't access the utilization, so
					 * remove the decision.
					 */
					String decisionKey = (String)
					    resourcesAwaitingImprovement.
					    get(res);
					if (decisionKey != null)
						decisions.remove(decisionKey);
				}
				it.remove();
			}
		}

		/*
		 * Expire decisions which have outlived
		 * DECISION_LIFETIME samples.
		 */
		int cutoff = mon.getSampleCount() - DECISION_LIFETIME;
		if (cutoff > 0) {
			Decision decision;
			ListIterator it = decisionList.listIterator(0);
			while (it.hasNext()) {
				decision = (Decision)it.next();
				int sc = decision.getStartingSampleCount();
				if (sc < cutoff) {
					if (sc > 0) {
						Poold.OPT_LOG.log(
						    Severity.DEBUG,
						    "expiring decision (" +
						    decision + ")");
						it.remove();
						decisions.remove(
						    decision.getKey());
					}
				} else
					break;
			}
		}
	}

	private void readObject(ObjectInputStream s)
	    throws IOException, ClassNotFoundException
	{
		s.defaultReadObject();

		resourcesAwaitingImprovement = new HashMap();
		decisionList = new LinkedList();
		for (Iterator it = decisions.keySet().iterator();
		    it.hasNext(); ) {
			String decisionKey = (String)it.next();
			Decision decision = (Decision)decisions.get(
			    decisionKey);
			decision.setStartingSampleCount(0);
			decisionList.add(decision);
		}
	}
}