Changeset d97c3a4 for src/ResolvExpr

Timestamp:

Jan 11, 2019, 2:16:53 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

52ffa30

Parents:

e99e43f

Message:

Fix new cost model by boosting precedence of safe costs

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (1 diff)
• ConversionCost.cc (modified) (1 diff)
• Cost.h (modified) (13 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -1229 +1229 @@
                                 Alternative newAlt{ 
                                         restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), 
-                                        alt.env, openVars, needAssertions, alt.cost, thisCost };
+                                        alt.env, openVars, needAssertions, alt.cost + thisCost, thisCost };
                                 inferParameters( newAlt, back_inserter( candidates ) );
                         } // if

src/ResolvExpr/ConversionCost.cc

@@ -29 +29 @@
 namespace ResolvExpr {
         const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0 };
-        const Cost Cost::infinity =  Cost{ -1, -1, -1,  1, -1, -1 };
+        const Cost Cost::infinity =  Cost{ -1, -1, -1, -1,  1, -1 };
         const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0 };
         const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0 };
-        const Cost Cost::var =       Cost{  0,  0,  1,  0,  0,  0 };
-        const Cost Cost::spec =      Cost{  0,  0,  0, -1,  0,  0 };
-        const Cost Cost::safe =      Cost{  0,  0,  0,  0,  1,  0 };
+        const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0 };
+        const Cost Cost::var =       Cost{  0,  0,  0,  1,  0,  0 };
+        const Cost Cost::spec =      Cost{  0,  0,  0,  0, -1,  0 };
         const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  1 };
 

src/ResolvExpr/Cost.h

@@ -21 +21 @@
         class Cost {
           private:
-                Cost( int unsafeCost, int polyCost, int varCost, int specCost, int safeCost, 
-                      int referenceCost );
+                Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost,
+                        int referenceCost );
 
           public:
                 Cost & incUnsafe( int inc = 1 );
                 Cost & incPoly( int inc = 1 );
+                Cost & incSafe( int inc = 1 );
                 Cost & incVar( int inc = 1 );
                 Cost & decSpec( int inc = 1 );
-                Cost & incSafe( int inc = 1 );
                 Cost & incReference( int inc = 1 );
 
                 int get_unsafeCost() const { return unsafeCost; }
                 int get_polyCost() const { return polyCost; }
+                int get_safeCost() const { return safeCost; }
                 int get_varCost() const { return varCost; }
                 int get_specCost() const { return specCost; }
-                int get_safeCost() const { return safeCost; }
                 int get_referenceCost() const { return referenceCost; }
 
@@ -54 +54 @@
                 static const Cost unsafe;
                 static const Cost poly;
+                static const Cost safe;
                 static const Cost var;
                 static const Cost spec;
-                static const Cost safe;
                 static const Cost reference;
 
@@ -62 +62 @@
                 int unsafeCost;     ///< Unsafe (narrowing) conversions
                 int polyCost;       ///< Count of parameters and return values bound to some poly type
+                int safeCost;       ///< Safe (widening) conversions
                 int varCost;        ///< Count of polymorphic type variables
                 int specCost;       ///< Polymorphic type specializations (type assertions), negative cost
-                int safeCost;       ///< Safe (widening) conversions
                 int referenceCost;  ///< reference conversions
         };
 
-        inline Cost::Cost( int unsafeCost, int polyCost, int varCost, int specCost, int safeCost, 
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost, 
                         int referenceCost ) 
-                : unsafeCost( unsafeCost ), polyCost( polyCost ), varCost( varCost ), specCost( specCost ), 
-                  safeCost( safeCost ), referenceCost( referenceCost ) {}
+                : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), varCost( varCost ), 
+                  specCost( specCost ), referenceCost( referenceCost ) {}
 
         inline Cost & Cost::incUnsafe( int inc ) {
@@ -85 +85 @@
         }
 
+        inline Cost & Cost::incSafe( int inc ) {
+                if ( *this == infinity ) return *this;
+                safeCost += inc;
+                return *this;
+        }
+
         inline Cost & Cost::incVar( int inc ) {
                 if ( *this == infinity ) return *this;
@@ -94 +100 @@
                 if ( *this == infinity ) return *this;
                 specCost -= dec;
-                return *this;
-        }
-
-        inline Cost & Cost::incSafe( int inc ) {
-                if ( *this == infinity ) return *this;
-                safeCost += inc;
                 return *this;
         }
@@ -112 +112 @@
                 if ( *this == infinity || other == infinity ) return infinity;
                 return Cost{ 
-                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, 
+                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, 
                         varCost + other.varCost, specCost + other.specCost, 
-                        safeCost + other.safeCost, referenceCost + other.referenceCost };
+                        referenceCost + other.referenceCost };
         }
 
@@ -120 +120 @@
                 if ( *this == infinity || other == infinity ) return infinity;
                 return Cost{ 
-                        unsafeCost - other.unsafeCost, polyCost - other.polyCost, 
+                        unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, 
                         varCost - other.varCost, specCost - other.specCost, 
-                        safeCost - other.safeCost, referenceCost - other.referenceCost };
+                        referenceCost - other.referenceCost };
         }
 
@@ -133 +133 @@
                 unsafeCost += other.unsafeCost;
                 polyCost += other.polyCost;
+                safeCost += other.safeCost;
                 varCost += other.varCost;
                 specCost += other.specCost;
-                safeCost += other.safeCost;
                 referenceCost += other.referenceCost;
                 return *this;
@@ -152 +152 @@
                 } else if ( polyCost < other.polyCost ) {
                         return true;
+                } else if ( safeCost > other.safeCost ) {
+                        return false;
+                } else if ( safeCost < other.safeCost ) {
+                        return true;
                 } else if ( varCost > other.varCost ) {
                         return false;
@@ -159 +163 @@
                         return false;
                 } else if ( specCost > other.specCost ) {
-                        return true;
-                } else if ( safeCost > other.safeCost ) {
-                        return false;
-                } else if ( safeCost < other.safeCost ) {
                         return true;
                 } else if ( referenceCost > other.referenceCost ) {
@@ -179 +179 @@
                 int c = unsafeCost - other.unsafeCost; if ( c ) return c;
                 c = polyCost - other.polyCost; if ( c ) return c;
+                c = safeCost - other.safeCost; if ( c ) return c;
                 c = varCost - other.varCost; if ( c ) return c;
                 c = specCost - other.specCost; if ( c ) return c;
-                c = safeCost - other.safeCost; if ( c ) return c;
                 return referenceCost - other.referenceCost;
         }
@@ -188 +188 @@
                 return unsafeCost == other.unsafeCost
                         && polyCost == other.polyCost
+                        && safeCost == other.safeCost
                         && varCost == other.varCost
                         && specCost == other.specCost
-                        && safeCost == other.safeCost
                         && referenceCost == other.referenceCost;
         }
@@ -200 +200 @@
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
                 return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " 
-                          << cost.varCost << ", " << cost.specCost << ", "
-                          << cost.safeCost << ", " << cost.referenceCost << " )";
+                          << cost.safeCost << ", " << cost.varCost << ", " << cost.specCost << ", "
+                          << cost.referenceCost << " )";
         }
 } // namespace ResolvExpr