/*
 * 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 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident        "%Z%%M% %I%     %E% SMI"
 *
 */

package com.sun.solaris.service.locality;

import java.util.*;

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

/**
 * A representation of an individual Locality Group. A Locality Group
 * resides within a Locality Domain.
 */
public class LocalityGroup
{
        /**
         * The locality domain which contains this group.
         */
        private LocalityDomain domain;

        /**
         * The C proxy id for this instance.
         */
        private long id;

        /**
         * The parent group of this instance.
         */
        private LocalityGroup parent;

        /**
         * The array of CPU IDs which are assigned to this instance.
         */
        private int cpu_ids[];

        /**
         * The child groups of this instance.
         */
        private Set children;

        /**
         * Constructor.
         *
         * @param domain is the domain to which this instance belongs.
         * @param id is the id of this instance.
         * @param parent is the parent of this instance.
         */
        public LocalityGroup(LocalityDomain domain, long id,
            LocalityGroup parent)
        {
                this.domain = domain;
                this.id = id;
                this.parent = parent;
                this.cpu_ids = jl_cpus();
                long nativeChildren[] = jl_children();
                children = new HashSet();
                for (int i = 0; i < nativeChildren.length; i++)
                        children.add(new LocalityGroup(domain,
                                     nativeChildren[i], this));
        }

        /**
         * Return a string representation of this instance.
         */
        public String toString()
        {
                StringBuffer sb = new StringBuffer().append("locality group ")
                    .append(id)
                    .append(" with cpus [");

                String sep = "";
                for (int i = 0; i < cpu_ids.length; i++) {
                        sb.append(sep);
                        sb.append(cpu_ids[i]);
                        sep = " ";
                }
                sb.append("]");

                return (sb.toString());
        }

        /**
         * Return the set of child locality groups for this instance.
         */
        public Set getChildren()
        {
                return (children);
        }

        /**
         * Return the array of CPU IDs which belong to this locality
         * group.
         */
        public int[] getCPUIDs()
        {
                return (cpu_ids);
        }

        /**
         * Return the locality group ID.
         */
        long getID()
        {
                return (id);
        }

        /**
         * Return the latency of the supplied group with respect to
         * this group.
         *
         * @param other is another locality group belonging to the
         * same LocalityDomain.
         */
        public int getLatency(LocalityGroup other)
        {
                return (jl_latency(id, other.getID()));
        }

        /**
         * Return the number of Latency Groups to which these cpus
         * belong which are not part of this group.
         *
         * @param cpus List of cpus to be examined.
         *
         * @throws PoolsException if there is an error accessing the
         * cpu details.
         */
        public int countForeignGroups(List cpus) throws PoolsException
        {
                Set groups = new HashSet();
                Iterator cpuIt = cpus.iterator();

                while (cpuIt.hasNext()) {
                        Component comp = (Component) cpuIt.next();
                        int id = (int) comp.getLongProperty("cpu.sys_id");
                        for (int i = 0; i < cpu_ids.length; i++) {
                                if (cpu_ids[i] == id) {
                                        LocalityGroup other = domain.
                                            getGroup(id);
                                        if (other != this &&
                                            groups.contains(other) == false)
                                                groups.add(other);
                                }
                        }
                }
                return (groups.size());
        }

        public Set contains(List cpus) throws PoolsException
        {
                Set contained = new HashSet();
                Iterator cpuIt = cpus.iterator();
                int set_cpus[] = getCPUIDs();

                while (cpuIt.hasNext()) {
                        Component comp = (Component) cpuIt.next();
                        for (int i = 0; i < set_cpus.length; i++) {
                                if (set_cpus[i] == (int)comp.getLongProperty(
                                        "cpu.sys_id")) {
                                        contained.add(comp);
                                        break;
                                }
                        }
                }
                return (contained);
        }

        /**
         * Return an array containing the child locality group IDs.
         */
        private native long[] jl_children();

        /**
         * Return an array of CPU IDs within this locality group.
         */
        private native int[] jl_cpus();

        /**
         * Return the latency between the two supplied lgrp IDs.
         *
         * @param id1 is the first id.
         * @param id2 is the second id.
         */
        private native int jl_latency(long id1, long id2);
}