Changes in / [4f7b418:bdfc032]

Files:

• benchmark/vector/glm_vec2.cc (added)
• benchmark/vector/vec2_notemplates.cfa (added)
• benchmark/vector/vec2_templates.cfa (added)
• libcfa/src/Makefile.am (modified) (1 diff)
• libcfa/src/Makefile.in (modified) (8 diffs)
• libcfa/src/vec/vec.hfa (added)
• libcfa/src/vec/vec2.hfa (added)
• libcfa/src/vec/vec3.hfa (added)
• libcfa/src/vec/vec4.hfa (added)
• src/ResolvExpr/ResolveAssertions.cc (modified) (1 diff)
• src/ResolvExpr/SatisfyAssertions.cpp (modified) (20 diffs)
• tests/vector_math/.expect/vec2_double.txt (added)
• tests/vector_math/.expect/vec2_float.txt (added)
• tests/vector_math/.expect/vec2_int.txt (added)
• tests/vector_math/.expect/vec2_ldouble.txt (added)
• tests/vector_math/.expect/vec2_uint.txt (added)
• tests/vector_math/.expect/vec3_float.txt (added)
• tests/vector_math/.expect/vec3_int.txt (added)
• tests/vector_math/.expect/vec4_float.txt (added)
• tests/vector_math/.expect/vec4_int.txt (added)
• tests/vector_math/glm_equivalents/vec2_float.cc (added)
• tests/vector_math/glm_equivalents/vec2_int.cc (added)
• tests/vector_math/glm_equivalents/vec3_float.cc (added)
• tests/vector_math/glm_equivalents/vec4_float.cc (added)
• tests/vector_math/vec2_double.cfa (added)
• tests/vector_math/vec2_float.cfa (added)
• tests/vector_math/vec2_int.cfa (added)
• tests/vector_math/vec2_ldouble.cfa (added)
• tests/vector_math/vec2_uint.cfa (added)
• tests/vector_math/vec3_float.cfa (added)
• tests/vector_math/vec3_int.cfa (added)
• tests/vector_math/vec4_float.cfa (added)
• tests/vector_math/vec4_int.cfa (added)

libcfa/src/Makefile.am

@@ -41 +41 @@
 headers_nosrc = math.hfa gmp.hfa time_t.hfa bits/align.hfa bits/containers.hfa bits/defs.hfa bits/debug.hfa bits/locks.hfa
 headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
-          containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa
+          containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa \
+          vec/vec.hfa vec/vec2.hfa vec/vec3.hfa vec/vec4.hfa
 
 libsrc = startup.cfa interpose.cfa bits/debug.cfa assert.cfa exception.c virtual.c heap.cfa ${headers:.hfa=.cfa}

libcfa/src/Makefile.in

@@ -142 +142 @@
         time.cfa stdlib.cfa common.cfa containers/maybe.cfa \
         containers/pair.cfa containers/result.cfa \
-        containers/vector.cfa
+        containers/vector.cfa vec/vec.cfa vec/vec2.cfa vec/vec3.cfa \
+        vec/vec4.cfa
 am__dirstamp = $(am__leading_dot)dirstamp
 @BUILDLIB_TRUE@am__objects_1 = fstream.lo iostream.lo iterator.lo \
@@ -148 +149 @@
 @BUILDLIB_TRUE@ common.lo containers/maybe.lo \
 @BUILDLIB_TRUE@ containers/pair.lo containers/result.lo \
-@BUILDLIB_TRUE@ containers/vector.lo
+@BUILDLIB_TRUE@ containers/vector.lo vec/vec.lo vec/vec2.lo \
+@BUILDLIB_TRUE@ vec/vec3.lo vec/vec4.lo
 @BUILDLIB_TRUE@am__objects_2 = startup.lo interpose.lo bits/debug.lo \
 @BUILDLIB_TRUE@ assert.lo exception.lo virtual.lo heap.lo \
@@ -237 +239 @@
         limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
         containers/maybe.hfa containers/pair.hfa containers/result.hfa \
-        containers/vector.hfa math.hfa gmp.hfa time_t.hfa \
-        bits/align.hfa bits/containers.hfa bits/defs.hfa \
-        bits/debug.hfa bits/locks.hfa concurrency/coroutine.hfa \
+        containers/vector.hfa vec/vec.hfa vec/vec2.hfa vec/vec3.hfa \
+        vec/vec4.hfa math.hfa gmp.hfa time_t.hfa bits/align.hfa \
+        bits/containers.hfa bits/defs.hfa bits/debug.hfa \
+        bits/locks.hfa concurrency/coroutine.hfa \
         concurrency/thread.hfa concurrency/kernel.hfa \
         concurrency/monitor.hfa concurrency/mutex.hfa \
@@ -460 +463 @@
 @BUILDLIB_FALSE@headers = 
 @BUILDLIB_TRUE@headers = fstream.hfa iostream.hfa iterator.hfa limits.hfa rational.hfa time.hfa stdlib.hfa common.hfa \
-@BUILDLIB_TRUE@   containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa
+@BUILDLIB_TRUE@   containers/maybe.hfa containers/pair.hfa containers/result.hfa containers/vector.hfa \
+@BUILDLIB_TRUE@   vec/vec.hfa vec/vec2.hfa vec/vec3.hfa vec/vec4.hfa
 
 @BUILDLIB_FALSE@libsrc = 
@@ -590 +594 @@
 containers/vector.lo: containers/$(am__dirstamp) \
         containers/$(DEPDIR)/$(am__dirstamp)
+vec/$(am__dirstamp):
+        @$(MKDIR_P) vec
+        @: > vec/$(am__dirstamp)
+vec/$(DEPDIR)/$(am__dirstamp):
+        @$(MKDIR_P) vec/$(DEPDIR)
+        @: > vec/$(DEPDIR)/$(am__dirstamp)
+vec/vec.lo: vec/$(am__dirstamp) vec/$(DEPDIR)/$(am__dirstamp)
+vec/vec2.lo: vec/$(am__dirstamp) vec/$(DEPDIR)/$(am__dirstamp)
+vec/vec3.lo: vec/$(am__dirstamp) vec/$(DEPDIR)/$(am__dirstamp)
+vec/vec4.lo: vec/$(am__dirstamp) vec/$(DEPDIR)/$(am__dirstamp)
 
 libcfa.la: $(libcfa_la_OBJECTS) $(libcfa_la_DEPENDENCIES) $(EXTRA_libcfa_la_DEPENDENCIES) 
@@ -629 +643 @@
         -rm -f containers/*.$(OBJEXT)
         -rm -f containers/*.lo
+        -rm -f vec/*.$(OBJEXT)
+        -rm -f vec/*.lo
 
 distclean-compile:
@@ -694 +710 @@
         -rm -rf concurrency/.libs concurrency/_libs
         -rm -rf containers/.libs containers/_libs
+        -rm -rf vec/.libs vec/_libs
 install-nobase_cfa_includeHEADERS: $(nobase_cfa_include_HEADERS)
         @$(NORMAL_INSTALL)
@@ -840 +857 @@
         -rm -f containers/$(DEPDIR)/$(am__dirstamp)
         -rm -f containers/$(am__dirstamp)
+        -rm -f vec/$(DEPDIR)/$(am__dirstamp)
+        -rm -f vec/$(am__dirstamp)
 
 maintainer-clean-generic:

src/ResolvExpr/ResolveAssertions.cc

@@ -390 +390 @@
 
         /// Limit to depth of recursion of assertion satisfaction
-        static const int recursionLimit = 4;
+        static const int recursionLimit = 7;
         /// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
         static const int deferLimit = 10;

src/ResolvExpr/SatisfyAssertions.cpp

@@ -57 +57 @@
                 ast::UniqueId resnSlot;          ///< Slot for any recursive assertion IDs
 
-                AssnCandidate( 
-                        const ast::SymbolTable::IdData c, const ast::Type * at, ast::TypeEnvironment && e, 
+                AssnCandidate(
+                        const ast::SymbolTable::IdData c, const ast::Type * at, ast::TypeEnvironment && e,
                         ast::AssertionSet && h, ast::AssertionSet && n, ast::OpenVarSet && o, ast::UniqueId rs )
-                : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ), 
+                : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
                   need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {}
         };
@@ -73 +73 @@
                 const AssnCandidate & match;
         };
-        
-        /// Wrapper for the deferred items from a single assertion satisfaction. 
+
+        /// Wrapper for the deferred items from a single assertion satisfaction.
         /// Acts like an indexed list of DeferRef
         struct DeferItem {
@@ -81 +81 @@
                 AssnCandidateList matches;
 
-                DeferItem( 
+                DeferItem(
                         const ast::DeclWithType * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
                 : decl( d ), info( i ), matches( std::move( ms ) ) {}
@@ -117 +117 @@
                 /// Initial satisfaction state for a candidate
                 SatState( CandidateRef & c, const ast::SymbolTable & syms )
-                : cand( c ), need(), newNeed(), deferred(), inferred(), costs{ Cost::zero }, 
+                : cand( c ), need(), newNeed(), deferred(), inferred(), costs{ Cost::zero },
                   symtab( syms ) { need.swap( c->need ); }
-                
+
                 /// Update satisfaction state for next step after previous state
                 SatState( SatState && o, IterateFlag )
-                : cand( std::move( o.cand ) ), need( o.newNeed.begin(), o.newNeed.end() ), newNeed(), 
-                  deferred(), inferred( std::move( o.inferred ) ), costs( std::move( o.costs ) ), 
+                : cand( std::move( o.cand ) ), need( o.newNeed.begin(), o.newNeed.end() ), newNeed(),
+                  deferred(), inferred( std::move( o.inferred ) ), costs( std::move( o.costs ) ),
                   symtab( o.symtab ) { costs.emplace_back( Cost::zero ); }
-                
+
                 /// Field-wise next step constructor
                 SatState(
-                        CandidateRef && c, ast::AssertionSet && nn, InferCache && i, CostVec && cs, 
+                        CandidateRef && c, ast::AssertionSet && nn, InferCache && i, CostVec && cs,
                         ast::SymbolTable && syms )
-                : cand( std::move( c ) ), need( nn.begin(), nn.end() ), newNeed(), deferred(), 
+                : cand( std::move( c ) ), need( nn.begin(), nn.end() ), newNeed(), deferred(),
                   inferred( std::move( i ) ), costs( std::move( cs ) ), symtab( std::move( syms ) )
                   { costs.emplace_back( Cost::zero ); }
@@ -143 +143 @@
 
         /// Binds a single assertion, updating satisfaction state
-        void bindAssertion( 
-                const ast::DeclWithType * decl, const ast::AssertionSetValue & info, CandidateRef & cand, 
+        void bindAssertion(
+                const ast::DeclWithType * decl, const ast::AssertionSetValue & info, CandidateRef & cand,
                 AssnCandidate & match, InferCache & inferred
         ) {
                 const ast::DeclWithType * candidate = match.cdata.id;
-                assertf( candidate->uniqueId, 
+                assertf( candidate->uniqueId,
                         "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
-                
+
                 ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cvtCost );
                 varExpr->result = match.adjType;
@@ -175 +175 @@
                         ast::OpenVarSet newOpen{ sat.cand->open };
                         ast::ptr< ast::Type > toType = assn.first->get_type();
-                        ast::ptr< ast::Type > adjType = 
+                        ast::ptr< ast::Type > adjType =
                                 renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ) );
 
@@ -187 +187 @@
                                 }
 
-                                matches.emplace_back( 
-                                        cdata, adjType, std::move( newEnv ), std::move( newNeed ), std::move( have ), 
+                                matches.emplace_back(
+                                        cdata, adjType, std::move( newEnv ), std::move( newNeed ), std::move( have ),
                                         std::move( newOpen ), crntResnSlot );
                         }
@@ -257 +257 @@
         };
 
-        /// Replace ResnSlots with InferParams and add alternative to output list, if it meets pruning 
+        /// Replace ResnSlots with InferParams and add alternative to output list, if it meets pruning
         /// threshold.
-        void finalizeAssertions( 
-                CandidateRef & cand, InferCache & inferred, PruneMap & thresholds, CostVec && costs, 
-                CandidateList & out 
+        void finalizeAssertions(
+                CandidateRef & cand, InferCache & inferred, PruneMap & thresholds, CostVec && costs,
+                CandidateList & out
         ) {
                 // prune if cheaper alternative for same key has already been generated
@@ -278 +278 @@
         }
 
-        /// Combo iterator that combines candidates into an output list, merging their environments. 
-        /// Rejects an appended candidate if environments cannot be merged. See `Common/FilterCombos.h` 
+        /// Combo iterator that combines candidates into an output list, merging their environments.
+        /// Rejects an appended candidate if environments cannot be merged. See `Common/FilterCombos.h`
         /// for description of "combo iterator".
         class CandidateEnvMerger {
@@ -299 +299 @@
                         Cost cost;
 
-                        OutType( 
-                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o, 
+                        OutType(
+                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o,
                                 const std::vector< DeferRef > & as, const ast::SymbolTable & symtab )
                         : env( e ), open( o ), assns( as ), cost( Cost::zero ) {
@@ -306 +306 @@
                                 for ( const DeferRef & assn : assns ) {
                                         // compute conversion cost from satisfying decl to assertion
-                                        cost += computeConversionCost( 
+                                        cost += computeConversionCost(
                                                 assn.match.adjType, assn.decl->get_type(), symtab, env );
-                                        
+
                                         // mark vars+specialization on function-type assertions
-                                        const ast::FunctionType * func = 
+                                        const ast::FunctionType * func =
                                                 GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
                                         if ( ! func ) continue;
@@ -317 +317 @@
                                                 cost.decSpec( specCost( param->get_type() ) );
                                         }
-                                        
+
                                         cost.incVar( func->forall.size() );
-                                        
+
                                         for ( const ast::TypeDecl * td : func->forall ) {
                                                 cost.decSpec( td->assertions.size() );
@@ -329 +329 @@
                 };
 
-                CandidateEnvMerger( 
-                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open, 
+                CandidateEnvMerger(
+                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open,
                         const ast::SymbolTable & syms )
                 : crnt(), envs{ env }, opens{ open }, symtab( syms ) {}
@@ -357 +357 @@
 
         /// Limit to depth of recursion of assertion satisfaction
-        static const int recursionLimit = 4;
+        static const int recursionLimit = 7;
         /// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
         static const int deferLimit = 10;
 } // anonymous namespace
 
-void satisfyAssertions( 
-        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out, 
+void satisfyAssertions(
+        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
         std::vector<std::string> & errors
 ) {
@@ -408 +408 @@
                                 // either add successful match or push back next state
                                 if ( sat.newNeed.empty() ) {
-                                        finalizeAssertions( 
+                                        finalizeAssertions(
                                                 sat.cand, sat.inferred, thresholds, std::move( sat.costs ), out );
                                 } else {
@@ -430 +430 @@
                                 std::vector< CandidateEnvMerger::OutType > compatible = filterCombos(
                                         sat.deferred, CandidateEnvMerger{ sat.cand->env, sat.cand->open, sat.symtab } );
-                                
+
                                 // fail early if no mutually-compatible assertion satisfaction
                                 if ( compatible.empty() ) {
@@ -453 +453 @@
                                         // set up next satisfaction state
                                         CandidateRef nextCand = std::make_shared<Candidate>(
-                                                sat.cand->expr, std::move( compat.env ), std::move( compat.open ), 
+                                                sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
                                                 ast::AssertionSet{} /* need moved into satisfaction state */,
                                                 sat.cand->cost, sat.cand->cvtCost );
@@ -459 +459 @@
                                         ast::AssertionSet nextNewNeed{ sat.newNeed };
                                         InferCache nextInferred{ sat.inferred };
-                                        
+
                                         CostVec nextCosts{ sat.costs };
                                         nextCosts.back() += compat.cost;
-                                                                
+
                                         ast::SymbolTable nextSymtab{ sat.symtab };
 
@@ -476 +476 @@
                                         // either add successful match or push back next state
                                         if ( nextNewNeed.empty() ) {
-                                                finalizeAssertions( 
+                                                finalizeAssertions(
                                                         nextCand, nextInferred, thresholds, std::move( nextCosts ), out );
                                         } else {
-                                                nextSats.emplace_back( 
-                                                        std::move( nextCand ), std::move( nextNewNeed ), 
-                                                        std::move( nextInferred ), std::move( nextCosts ), 
+                                                nextSats.emplace_back(
+                                                        std::move( nextCand ), std::move( nextNewNeed ),
+                                                        std::move( nextInferred ), std::move( nextCosts ),
                                                         std::move( nextSymtab ) );
                                         }
@@ -493 +493 @@
                 nextSats.clear();
         }
-        
+
         // exceeded recursion limit if reaches here
         if ( out.empty() ) {