jdk8-mips64-public/hotspot: src/share/vm/libadt/vectset.cpp@f90c822e73f8 (annotated)

src/share/vm/libadt/vectset.cpp@f90c822e73f8 (annotated)

src/share/vm/libadt/vectset.cpp

Wed, 27 Apr 2016 01:25:04 +0800

author: aoqi
date: Wed, 27 Apr 2016 01:25:04 +0800
changeset 0: f90c822e73f8
child 6876: 710a3c8b516e
permissions: -rw-r--r--

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/hotspot/
changeset: 6782:28b50d07f6f8
tag: jdk8u25-b17

 /*
  * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #include "precompiled.hpp"
 #include "libadt/vectset.hpp"
 #include "memory/allocation.inline.hpp"
 // Vector Sets - An Abstract Data Type
 // %%%%% includes not needed with AVM framework - Ungar
 // #include "port.hpp"
 //IMPLEMENTATION
 // #include "vectset.hpp"
 // BitsInByte is a lookup table which tells the number of bits that
 // are in the looked-up number.  It is very useful in VectorSet_Size.
 uint8 bitsInByte[256] = {
 , 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
 , 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 , 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 , 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 , 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 , 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 , 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 , 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
 , 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
 , 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 , 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 , 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
 , 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
 , 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
 , 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
 , 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
 };
 //------------------------------VectorSet--------------------------------------
 // Create a new, empty Set.
 VectorSet::VectorSet(Arena *arena) : Set(arena) {
   size = 2;                     // Small initial size
   data = (uint32 *)_set_arena->Amalloc(size*sizeof(uint32));
   data[0] = 0;                  // No elements
   data[1] = 0;
 }
 //------------------------------Construct--------------------------------------
 Set &VectorSet_Construct(Arena *arena)
 {
   return *(new VectorSet(arena));
 }
 //------------------------------operator=--------------------------------------
 Set &VectorSet::operator = (const Set &set)
 {
   if( &set == this ) return *this;
   FREE_FAST(data);
   // The cast is a virtual function that checks that "set" is a VectorSet.
   slamin(*(set.asVectorSet()));
   return *this;
 }
 //------------------------------slamin-----------------------------------------
 // Initialize one set with another.  No regard is made to the existing Set.
 void VectorSet::slamin(const VectorSet& s)
 {
   size = s.size;                // Use new size
   data = (uint32*)s._set_arena->Amalloc(size*sizeof(uint32)); // Make array of required size
   memcpy( data, s.data, size*sizeof(uint32) ); // Fill the array
 }
 //------------------------------grow-------------------------------------------
 // Expand the existing set to a bigger size
 void VectorSet::grow( uint newsize )
 {
   newsize = (newsize+31) >> 5;  // Convert to longwords
   uint x = size;
   while( x < newsize ) x <<= 1;
   data = (uint32 *)_set_arena->Arealloc(data, size*sizeof(uint32), x*sizeof(uint32));
   memset((char *)(data + size), 0, (x - size)*sizeof(uint32));
   size = x;
 }
 //------------------------------operator<<=------------------------------------
 // Insert a member into an existing Set.
 Set &VectorSet::operator <<= (uint elem)
 {
   register uint word = elem >> 5;            // Get the longword offset
   register uint32 mask = 1L << (elem & 31);  // Get bit mask
   if( word >= size )            // Need to grow set?
     grow(elem+1);               // Then grow it
   data[word] |= mask;           // Set new bit
   return *this;
 }
 //------------------------------operator>>=------------------------------------
 // Delete a member from an existing Set.
 Set &VectorSet::operator >>= (uint elem)
 {
   register uint word = elem >> 5; // Get the longword offset
   if( word >= size )              // Beyond the last?
     return *this;                 // Then it's clear & return clear
   register uint32 mask = 1L << (elem & 31);     // Get bit mask
   data[word] &= ~mask;            // Clear bit
   return *this;
 }
 //------------------------------operator&=-------------------------------------
 // Intersect one set into another.
 VectorSet &VectorSet::operator &= (const VectorSet &s)
 {
   // NOTE: The intersection is never any larger than the smallest set.
   if( s.size < size ) size = s.size; // Get smaller size
   register uint32 *u1 = data;   // Pointer to the destination data
   register uint32 *u2 = s.data; // Pointer to the source data
   for( uint i=0; i<size; i++)   // For data in set
     *u1++ &= *u2++;             // Copy and AND longwords
   return *this;                 // Return set
 }
 //------------------------------operator&=-------------------------------------
 Set &VectorSet::operator &= (const Set &set)
 {
   // The cast is a virtual function that checks that "set" is a VectorSet.
   return (*this) &= *(set.asVectorSet());
 }
 //------------------------------operator|=-------------------------------------
 // Union one set into another.
 VectorSet &VectorSet::operator |= (const VectorSet &s)
 {
   // This many words must be unioned
   register uint cnt = ((size<s.size)?size:s.size);
   register uint32 *u1 = data;   // Pointer to the destination data
   register uint32 *u2 = s.data; // Pointer to the source data
   for( uint i=0; i<cnt; i++)    // Copy and OR the two sets
     *u1++ |= *u2++;
   if( size < s.size ) {         // Is set 2 larger than set 1?
     // Extend result by larger set
     grow(s.size*sizeof(uint32)*8);
     memcpy(&data[cnt], u2, (s.size - cnt)*sizeof(uint32));
   }
   return *this;                 // Return result set
 }
 //------------------------------operator|=-------------------------------------
 Set &VectorSet::operator |= (const Set &set)
 {
   // The cast is a virtual function that checks that "set" is a VectorSet.
   return (*this) |= *(set.asVectorSet());
 }
 //------------------------------operator-=-------------------------------------
 // Difference one set from another.
 VectorSet &VectorSet::operator -= (const VectorSet &s)
 {
   // This many words must be unioned
   register uint cnt = ((size<s.size)?size:s.size);
   register uint32 *u1 = data;   // Pointer to the destination data
   register uint32 *u2 = s.data; // Pointer to the source data
   for( uint i=0; i<cnt; i++ )   // For data in set
     *u1++ &= ~(*u2++);          // A <-- A & ~B  with longwords
   return *this;                 // Return new set
 }
 //------------------------------operator-=-------------------------------------
 Set &VectorSet::operator -= (const Set &set)
 {
   // The cast is a virtual function that checks that "set" is a VectorSet.
   return (*this) -= *(set.asVectorSet());
 }
 //------------------------------compare----------------------------------------
 // Compute 2 booleans: bits in A not B, bits in B not A.
 // Return X0 --  A is not a subset of B
 //        X1 --  A is a subset of B
 //        0X --  B is not a subset of A
 //        1X --  B is a subset of A
 int VectorSet::compare (const VectorSet &s) const
 {
   register uint32 *u1 = data;   // Pointer to the destination data
   register uint32 *u2 = s.data; // Pointer to the source data
   register uint32 AnotB = 0, BnotA = 0;
   // This many words must be unioned
   register uint cnt = ((size<s.size)?size:s.size);
   // Get bits for both sets
   uint i;                       // Exit value of loop
   for( i=0; i<cnt; i++ ) {      // For data in BOTH sets
     register uint32 A = *u1++;  // Data from one guy
     register uint32 B = *u2++;  // Data from other guy
     AnotB |= (A & ~B);          // Compute bits in A not B
     BnotA |= (B & ~A);          // Compute bits in B not A
   }
   // Get bits from bigger set
   if( size < s.size ) {
     for( ; i<s.size; i++ )      // For data in larger set
       BnotA |= *u2++;           // These bits are in B not A
   } else {
     for( ; i<size; i++ )        // For data in larger set
       AnotB |= *u1++;           // These bits are in A not B
   }
   // Set & return boolean flags
   return ((!BnotA)<<1) + (!AnotB);
 }
 //------------------------------operator==-------------------------------------
 // Test for set equality
 int VectorSet::operator == (const VectorSet &s) const
 {
   return compare(s) == 3;       // TRUE if A and B are mutual subsets
 }
 //------------------------------operator==-------------------------------------
 int VectorSet::operator == (const Set &set) const
 {
   // The cast is a virtual function that checks that "set" is a VectorSet.
   return (*this) == *(set.asVectorSet());
 }
 //------------------------------disjoint---------------------------------------
 // Check for sets being disjoint.
 int VectorSet::disjoint(const Set &set) const
 {
   // The cast is a virtual function that checks that "set" is a VectorSet.
   const VectorSet &s = *(set.asVectorSet());
   // NOTE: The intersection is never any larger than the smallest set.
   register uint small_size = ((size<s.size)?size:s.size);
   register uint32 *u1 = data;        // Pointer to the destination data
   register uint32 *u2 = s.data;      // Pointer to the source data
   for( uint i=0; i<small_size; i++)  // For data in set
     if( *u1++ & *u2++ )              // If any elements in common
       return 0;                      // Then not disjoint
   return 1;                          // Else disjoint
 }
 //------------------------------operator<--------------------------------------
 // Test for strict subset
 int VectorSet::operator < (const VectorSet &s) const
 {
   return compare(s) == 1;       // A subset B, B not subset A
 }
 //------------------------------operator<--------------------------------------
 int VectorSet::operator < (const Set &set) const
 {
   // The cast is a virtual function that checks that "set" is a VectorSet.
   return (*this) < *(set.asVectorSet());
 }
 //------------------------------operator<=-------------------------------------
 // Test for subset
 int VectorSet::operator <= (const VectorSet &s) const
 {
   return compare(s) & 1;        // A subset B
 }
 //------------------------------operator<=-------------------------------------
 int VectorSet::operator <= (const Set &set) const
 {
   // The cast is a virtual function that checks that "set" is a VectorSet.
   return (*this) <= *(set.asVectorSet());
 }
 //------------------------------operator[]-------------------------------------
 // Test for membership.  A Zero/Non-Zero value is returned!
 int VectorSet::operator[](uint elem) const
 {
   register uint word = elem >> 5; // Get the longword offset
   if( word >= size )              // Beyond the last?
     return 0;                     // Then it's clear
   register uint32 mask = 1L << (elem & 31);  // Get bit mask
   return ((data[word] & mask))!=0;           // Return the sense of the bit
 }
 //------------------------------getelem----------------------------------------
 // Get any element from the set.
 uint VectorSet::getelem(void) const
 {
   uint i;                       // Exit value of loop
   for( i=0; i<size; i++ )
     if( data[i] )
       break;
   uint32 word = data[i];
   int j;                        // Exit value of loop
   for( j= -1; word; j++, word>>=1 );
   return (i<<5)+j;
 }
 //------------------------------Clear------------------------------------------
 // Clear a set
 void VectorSet::Clear(void)
 {
   if( size > 100 ) {            // Reclaim storage only if huge
     FREE_RESOURCE_ARRAY(uint32,data,size);
     size = 2;                   // Small initial size
     data = NEW_RESOURCE_ARRAY(uint32,size);
   }
   memset( data, 0, size*sizeof(uint32) );
 }
 //------------------------------Size-------------------------------------------
 // Return number of elements in a Set
 uint VectorSet::Size(void) const
 {
   uint sum = 0;                 // Cumulative size so far.
   uint8 *currByte = (uint8*)data;
   for( uint32 i = 0; i < (size<<2); i++) // While have bytes to process
     sum += bitsInByte[*currByte++];      // Add bits in current byte to size.
   return sum;
 }
 //------------------------------Sort-------------------------------------------
 // Sort the elements for the next forall statement
 void VectorSet::Sort(void)
 {
 }
 //------------------------------hash-------------------------------------------
 int VectorSet::hash() const
 {
   uint32 _xor = 0;
   uint lim = ((size<4)?size:4);
   for( uint i = 0; i < lim; i++ )
     _xor ^= data[i];
   return (int)_xor;
 }
 //------------------------------iterate----------------------------------------
 // Used by Set::print().
 class VSetI_ : public SetI_ {
   VectorSetI vsi;
 public:
   VSetI_( const VectorSet *vset, uint &elem ) : vsi(vset) { elem = vsi.elem; }
   uint next(void) { ++vsi; return vsi.elem; }
   int  test(void) { return vsi.test(); }
 };
 SetI_ *VectorSet::iterate(uint &elem) const {
   return new(ResourceObj::C_HEAP, mtInternal) VSetI_(this, elem);
 }
 //=============================================================================
 //------------------------------next-------------------------------------------
 // Find and return the next element of a vector set, or return garbage and
 // make "VectorSetI::test()" fail.
 uint VectorSetI::next(void)
 {
   j++;                          // Next element in word
   mask = (mask & max_jint) << 1;// Next bit in word
   do {                          // Do While still have words
     while( mask ) {             // While have bits in word
       if( s->data[i] & mask ) { // If found a bit
         return (i<<5)+j;        // Return the bit address
       }
       j++;                      // Skip to next bit
       mask = (mask & max_jint) << 1;
     }
     j = 0;                      // No more bits in word; setup for next word
     mask = 1;
     for( i++; (i<s->size) && (!s->data[i]); i++ ); // Skip to non-zero word
   } while( i<s->size );
   return max_juint;             // No element, iterated them all
 }

Mercurial > jdk8-mips64-public > hotspot / annotate

src/share/vm/libadt/vectset.cpp@f90c822e73f8 (annotated)

src/share/vm/libadt/vectset.cpp