Merge branch 'charm' of charmgit:charm into charm
authorAaron Becker <akbecker@gmail.com>
Fri, 28 Jan 2011 18:55:37 +0000 (12:55 -0600)
committerAaron Becker <akbecker@gmail.com>
Fri, 28 Jan 2011 18:55:37 +0000 (12:55 -0600)
88 files changed:
doc/charm++/entry.tex
doc/charm++/kmeans.cpp [new file with mode: 0644]
doc/charm++/loadb.tex
doc/charm++/manual.tex
doc/charm++/messages.tex
doc/charm++/msa.tex [new file with mode: 0644]
doc/charm++/nodegroups.tex
doc/charm++/order.tex [new file with mode: 0644]
examples/bigsim/tools/text2log/Makefile [new file with mode: 0644]
examples/bigsim/tools/text2log/README [new file with mode: 0644]
examples/bigsim/tools/text2log/eventTemplates.txt [new file with mode: 0644]
examples/bigsim/tools/text2log/examples.tgz [new file with mode: 0644]
examples/bigsim/tools/text2log/log0.txt [new file with mode: 0644]
examples/bigsim/tools/text2log/text2log.C [new file with mode: 0644]
examples/charm++/Makefile
examples/charm++/cell/md/md_config.h
examples/charm++/imbalanced/LB_Bench.C [deleted file]
examples/charm++/imbalanced/LB_Bench.ci [deleted file]
examples/charm++/imbalanced/Makefile [deleted file]
examples/charm++/imbalanced/README [deleted file]
examples/charm++/jacobi3d-sdag/jacobi3d.C
examples/charm++/load_balancing/Makefile [new file with mode: 0644]
examples/charm++/load_balancing/kNeighbor/Makefile [new file with mode: 0644]
examples/charm++/load_balancing/kNeighbor/kNeighbor.C [new file with mode: 0644]
examples/charm++/load_balancing/kNeighbor/kNeighbor.ci [new file with mode: 0644]
examples/charm++/load_balancing/stencil3d/Makefile [new file with mode: 0644]
examples/charm++/load_balancing/stencil3d/stencil3d.C [new file with mode: 0644]
examples/charm++/load_balancing/stencil3d/stencil3d.ci [new file with mode: 0644]
examples/charm++/simple_imbalance/LB_Test.C [deleted file]
examples/charm++/simple_imbalance/LB_Test.ci [deleted file]
examples/charm++/simple_imbalance/Makefile [deleted file]
src/QuickThreads/mkfiles/aix64-light [new file with mode: 0644]
src/arch/bluegenep/machine.c
src/arch/lapi/cc-mpcc64.sh
src/arch/lapi/conv-mach.sh
src/arch/mpi-linux-x86_64/cc-mpicxx.sh
src/arch/net/charmrun/charmrun.c
src/arch/net/machine-recover.c
src/ck-core/ckdirect.h
src/ck-core/cklocation.C
src/ck-core/ckmemcheckpoint.C
src/ck-ldb/ckgraph.C
src/conv-core/cmidirect.h
src/langs/charj/src/charj/libs/Array.h
src/libs/ck-libs/ParFUM-Iterators/Makefile
src/libs/ck-libs/ParFUM-Iterators/ParFUM_Iterators.cc
src/libs/ck-libs/ParFUM-Iterators/ParFUM_Iterators.h
src/libs/ck-libs/ParFUM-Tops/Makefile
src/libs/ck-libs/ParFUM/Makefile
src/libs/ck-libs/ParFUM/ParFUM_internals.h
src/libs/ck-libs/multiphaseSharedArrays/msa-distArray.h
src/libs/ck-libs/pose/rep.h
src/libs/ck-libs/pose/sim.ci
src/libs/ck-libs/pose/sim.h
src/scripts/configure
src/scripts/configure.in
src/scripts/conv-config.sh
src/util/CrayNid.c
src/util/TopoManager.C
src/util/pup_stl.h
src/util/simd.h
tests/charm++/Makefile
tests/charm++/load_balancing/Makefile [moved from tests/charm++/loadbalancing/Makefile with 94% similarity]
tests/charm++/load_balancing/lb_test/Makefile [moved from tests/charm++/loadbalancing/lb_test/Makefile with 100% similarity]
tests/charm++/load_balancing/lb_test/README [moved from tests/charm++/loadbalancing/lb_test/README with 100% similarity]
tests/charm++/load_balancing/lb_test/Topo.C [moved from tests/charm++/loadbalancing/lb_test/Topo.C with 100% similarity]
tests/charm++/load_balancing/lb_test/Topo.ci [moved from tests/charm++/loadbalancing/lb_test/Topo.ci with 100% similarity]
tests/charm++/load_balancing/lb_test/Topo.h [moved from tests/charm++/loadbalancing/lb_test/Topo.h with 100% similarity]
tests/charm++/load_balancing/lb_test/lb_test.C [moved from tests/charm++/loadbalancing/lb_test/lb_test.C with 100% similarity]
tests/charm++/load_balancing/lb_test/lb_test.ci [moved from tests/charm++/loadbalancing/lb_test/lb_test.ci with 100% similarity]
tests/charm++/load_balancing/lb_test/predictor/Makefile [moved from tests/charm++/loadbalancing/lb_test/predictor/Makefile with 100% similarity]
tests/charm++/load_balancing/lb_test/predictor/test.C [moved from tests/charm++/loadbalancing/lb_test/predictor/test.C with 100% similarity]
tests/charm++/load_balancing/lb_test/predictor/test.ci [moved from tests/charm++/loadbalancing/lb_test/predictor/test.ci with 100% similarity]
tests/charm++/load_balancing/lb_test/predictor/test.h [moved from tests/charm++/loadbalancing/lb_test/predictor/test.h with 100% similarity]
tests/charm++/load_balancing/lb_test/sim/Makefile [moved from tests/charm++/loadbalancing/lb_test/sim/Makefile with 100% similarity]
tests/charm++/load_balancing/lb_test/sim/Topo.C [moved from tests/charm++/loadbalancing/lb_test/sim/Topo.C with 100% similarity]
tests/charm++/load_balancing/lb_test/sim/Topo.ci [moved from tests/charm++/loadbalancing/lb_test/sim/Topo.ci with 100% similarity]
tests/charm++/load_balancing/lb_test/sim/Topo.h [moved from tests/charm++/loadbalancing/lb_test/sim/Topo.h with 100% similarity]
tests/charm++/load_balancing/lb_test/sim/sim.C [moved from tests/charm++/loadbalancing/lb_test/sim/sim.C with 100% similarity]
tests/charm++/load_balancing/lb_test/sim/sim.ci [moved from tests/charm++/loadbalancing/lb_test/sim/sim.ci with 100% similarity]
tests/charm++/loadbalancing/jacobi2D-periodic-lb/Jacobi2D.C [deleted file]
tests/charm++/loadbalancing/jacobi2D-periodic-lb/Jacobi2D.ci [deleted file]
tests/charm++/loadbalancing/jacobi2D-periodic-lb/Jacobi2D.h [deleted file]
tests/charm++/loadbalancing/jacobi2D-periodic-lb/Makefile [deleted file]
tests/charm++/loadbalancing/jacobi2D/Jacobi2D.C [deleted file]
tests/charm++/loadbalancing/jacobi2D/Jacobi2D.ci [deleted file]
tests/charm++/loadbalancing/jacobi2D/Jacobi2D.h [deleted file]
tests/charm++/loadbalancing/jacobi2D/Makefile [deleted file]

index fd16eaf092613a1ca079405c00bba9a9b0b77f40..4f58758a15dded001833747b46fadfd84a5b5a94 100644 (file)
@@ -44,26 +44,23 @@ an entry method:
 \kw{threaded}, \kw{sync}, \kw{exclusive}, \kw{nokeep}, \kw{notrace}, \kw{immediate}, \kw{expedited}, \kw{inline}, \kw{local}, \kw{python}.
 
 \begin{description}
-\index{threaded}\item[threaded] \index{entry method}entry methods are simply entry
-methods which are run in their own nonpremptible threads.  To make an
-\index{entry method}entry method threaded, one simply adds the keyword
-\kw{threaded} to the attribute list of that entry method.
+\index{threaded}\item[threaded] \index{entry method}entry methods are
+entry methods which are run in their own nonpreemptible threads. These
+entry methods may perform blocking operations, such as calls to a
+\kw{sync} entry method, or explicitly suspend themselves.
 
 \index{sync}\item[sync] \index{entry method}entry methods are special in that calls to
 sync entry methods are blocking - they do not return control to the caller
 until the method is finished executing completely.  Sync methods may have
-return values; however, they may only return messages.  To make an \index{entry
-method}entry method a sync entry method, add the keyword \kw{sync} to the
-attribute list of that entry method.
+return values; however, they may only return messages. Callers must run in a
+thread separate from the runtime scheduler, e.g. a \kw{threaded} entry methods.
 
 \index{exclusive}\item[exclusive] entry methods, which exist only on node groups, are
 \index{entry method}entry methods that do not execute while other exclusive
 \index{entry method}entry methods of its node group are executing in the same
 node.  If one exclusive method of a node group is executing on node 0, and
 another one is scheduled to run on that same node, the second exclusive method
-will wait for the first to finish before it executes.  To make an \index{entry
-method}entry method exclusive, add the keyword \kw{exclusive} to that
-entry method's attribute list.
+will wait for the first to finish before it executes.
 
 \index{nokeep}\item[nokeep] entry methods tells Charm++ that messages passed to
 these user entry methods will not be kept by the calls. Charm++ runtime
@@ -89,7 +86,7 @@ that skip Charm++'s priority-based message queue. It is useful for messages that
 require prompt processing however in the situation when immediate message does
 not apply. Compared with immediate message, it provides a more general solution
 that works for all Charm++ objects, i.e. Chare, Group, NodeGroup and Chare
-Array. However, skipscheduler message still needs to be scheduled in low level
+Array. However, expedited message still needs to be scheduled in low level
 Converse message queue and be processed in the order of arrival. It may still
 suffer from long running entry methods.
 
diff --git a/doc/charm++/kmeans.cpp b/doc/charm++/kmeans.cpp
new file mode 100644 (file)
index 0000000..4df2006
--- /dev/null
@@ -0,0 +1,38 @@
+// One instance is created and called on each PE
+void KMeansGroup::cluster()
+{
+  CLUSTERS::Write w = clusters.getInitialWrite();
+  if (initSeed != -1) writePosition(w, initSeed);
+
+  // Put the array in Read mode
+  CLUSTERS::Read r = w.syncToRead();
+
+  do {
+    // Each PE finds the seed closest to itself
+    double minDistance = distance(r, curSeed);
+    
+    for (int i = 0; i < numClusters; ++i) {
+      double d = distance(r, i);
+      if(d < minDistance) {
+       minDistance = d;
+       newSeed = i;
+      }
+    }
+
+    // Put the array in Accumulate mode, 
+    // excluding the current value
+    CLUSTERS::Accum a = r.syncToExcAccum();
+    // Each PE adds itself to its new seed
+    for (int i = 0; i < numMetrics; ++i)
+      a(newSeed, i) += metrics[i];
+
+    // Update membership and change count
+    a(newSeed, numMetrics) += 1;
+    if (curSeed != newSeed)
+      a(0, numMetrics+1) += 1;
+    curSeed = newSeed;
+      
+    // Put the array in Read mode
+    r = a.syncToRead();
+  } while(r(0, numMetrics+1) > 0);
+}
index 041557d22ac32cf1a1984d2da26f834837c5bdb4..9d87a5b469478a7f3d38d304872331c8df4c21d4 100644 (file)
@@ -5,7 +5,7 @@
 
 %(This introduction added on 11/12/2003)
 
-Charm++ supports Load Balancing, enabled by the fact there are a large
+Charm++ supports load balancing, enabled by the fact there are a large
 number of chares or chare-array-elements typically available to map to
 existing processors, and that they can be migrated at runtime.
 
@@ -43,7 +43,7 @@ processor. The seed balancer will handle such work as it arises.
 \label{lbFramework}
 \label{migrationlb}
 
-In \charmpp{}, objects(except groups, nodegroups) can migrate from 
+In \charmpp{}, objects (except groups, nodegroups) can migrate from 
 processor to processor at run-time. Object migration can potentially 
 improve the performance of the parallel program by migrating objects from 
 overloaded processors to underloaded ones. 
@@ -68,15 +68,18 @@ measurement-based load balancing without application-specific knowledge.
 
 Here are the two terms often used in \charmpp{} load balancing framework:
 \begin{itemize}
-\item \kw{Load balancing database} provides the interface of almost all
-   load balancing calls. On each processor, it stores the load
-   balancing instrumented data and coordinates the load balancing manager and
-   balancer. it is implemented as a Chare Group called {\kw LBDatabase}.
-\item \kw{Load balancer or strategy} takes the load balancing database
-   and produces the new mapping of the objects. In \charmpp{}, it is
-   implemented as Chare Group inherited from BaseLB. Two kinds of schemes are
-   implemented, they are (a) centralized load balancers and (b)
-   distributed load balancers.
+%
+\item \kw{Load balancing database} provides the interface of almost all load
+balancing calls. On each processor, it stores the load balancing instrumented
+data and coordinates the load balancing manager and balancer. it is implemented
+as a Chare Group called \kw{LBDatabase}.
+%
+\item \kw{Load balancer or strategy} takes the load balancing database and
+produces the new mapping of the objects. In \charmpp{}, it is implemented as
+Chare Group inherited from BaseLB. Three kinds of schemes are implemented: (a)
+centralized load balancers, (b) fully distributed load balancers and (c)
+hierarchical load balancers.
+%
 \end{itemize}
 
 \subsubsection{Available Load Balancing Strategies}
@@ -84,7 +87,7 @@ Here are the two terms often used in \charmpp{} load balancing framework:
 \label{lbStrategy}
 
 Load balancing can be performed in either a centralized, fully distributed
-or hierarchical (or hybrid) fashion.
+or hierarchical fashion.
 
 In centralized approaches, the entire machine's load and communication
 structure are accumulated to a single point, typically processor 0, followed by
@@ -99,17 +102,17 @@ neighboring processors. There is no global synchronization. However,
 they will not, in general, provide an immediate restoration for load balance -
 the process is iterated until the load balance can be achieved.
 
-
 In hierarchical approaches, processors are divided into independent autonomous
 sets of processor groups and these groups are organized in hierarchies,
-therefore decentralizing the load balancing task. Hybrid strategies are used to
-load balancing load on processors inside each processor group, and processors
-across groups in a hierarchical fashion. 
+therefore decentralizing the load balancing task. Different strategies can be
+used to load balancing load on processors inside each processor group, and
+processors across groups in a hierarchical fashion.
 
-Listed below are some of the available nontrivial centralized load balancers and their brief descriptions:
+Listed below are some of the available non-trivial centralized load balancers
+and their brief descriptions:
 \begin{itemize}
 \item {\bf RandCentLB}:   Randomly assigns objects to processors;
-\item {\bf RecBisectBfLB}:        Recursively partition with Breadth first enumeration;
+%\item {\bf RecBisectBfLB}:        Recursively partition with Breadth first enumeration;
 \item {\bf MetisLB}:      Use Metis(tm) to partitioning object communication graph;
 \item {\bf GreedyLB}:   Use greedy algorithm, always pick the heaviest object to the least loaded processor.
 \item {\bf GreedyCommLB}:       Greedy algorithm which also takes communication graph into account;
@@ -126,9 +129,15 @@ Listed below are the distributed load balancers:
 \item {\bf WSLB}:   A load balancer for workstation clusters, which can detect load changes on desktops (and other timeshared processors) and adjust load without interferes with other's use of the desktop.
 \end{itemize}
 
-User can choose any load balancing strategy he or she thinks is good for the
-application.  The compiler and run-time options are described in section
-\ref{lbOption}.
+An example of a hierarchical strategy can be found in:
+\begin{itemize}
+\item {\bf HybridLB}: This calls GreedyLB at the lower level and RefineLB at
+the root.
+\end{itemize}
+
+Users can choose any load balancing strategy they think is good for their
+application. The compiler and run-time options are described in
+section~\ref{lbOption}.
 
 %In some cases, one may need to create and invoke multiple load balancing
 %strategies/algorithms at the different phases. \charmpp{} now supports
@@ -137,136 +146,95 @@ application.  The compiler and run-time options are described in section
 %step, and use RefineLB for the later load balancing steps.
 
 \subsubsection{Load Balancing Chare Arrays}
-
 \label{lbarray}
 
-Load balancing framework is well integrated with Chare array implementation - 
-when a chare array is created, it automatically registers its elements 
-with the load balancing framework. The instrumentation of compute time (wall/cpu time) 
-and communication pattern are done automatically and APIs are provided 
-for users to trigger the load balancing. 
-
-To use the load balancer, you must make your array elements migratable
-(see migration section above) and choose a \kw{load balancing strategy} 
-(see the section \ref{lbStrategy} for a description
-of available load balancing strategies).
-
-We implemented three methods to use load balancing for chare arrays
-to meet different needs of the applications. These methods
-are different in how and when a load balancing phase starts.
-The three methods are: {\bf periodic load balancing mode}, 
-{\bf automatic with Sync mode} and {\bf manual mode}.
-
-In {\em periodic load balancing mode}, a user just needs to specify how
-often he wants the load balancing to occur, using +LBPeriod runtime
-option to specify a time interval. 
-
-In {\em sync mode}, users can tell load balancer explicitly when is a good 
-time to trigger load balancing by inserting a function call in the user
-code.
-
-
-%In this mode, load balancer works in parallel with 
-%the application so application doesn't need to stop waiting for load 
-%balancing to complete. However, in most cases, 
-%application does not want load balancing to occur arbitrarily because it 
-%has better idea about when a load balancing should 
-%happen\footnote{For example, in the application with multiple iterations, 
-%load balancing should happens in every a few iterations}. 
-%{\em Automatic with sync} mode is designed for this 
-%scenario. In this mode, user inserts {\em AtSync()} calls at certain points 
-%in application where he thinks the load balancing is desired. 
-%Load balancing is then triggered after all the local array elements on 
-%the processor reach the sync point\footnote{It is implemented as a local 
-%barrier of all the array elements on one processor}. 
-%However, {\em AtSync()} is not a blocking call, 
-%load balancing does not force the application to block until it  
-%finishes. When load balancing finishes, load balancer notifies every array
-%element by calling {\em ResumeFromSync()}
-%\footnote{{\em ResumeFromSync()} is a virtual function of array element
-%base class which can be redefined in application.}. In many applications,
-%it is often desirable that application waits for load balancing complete since
-%there may be migration occurs when load balancing and application may want to
-%respond to the migration. Thus, one of the commonly applied strategy is 
-%that array elements stop sending message after {\em AtSync()} is called, 
-%and resume work after load balancer calls back {\em ResumeFromSync()}.
-
-In the above two load balancing modes, users don't need 
-to worry about how to start load balancing. 
-However, in one scenario, the above automatic load balancers will fail to
-work - array elements are created by dynamic insertion.
-This is because the above two load balancing modes require an application
-to have fixed number of objects at the time of load balancing.
-The array manager needs to maintain a head count of local array elements
-for the local barrier.
-In this case, users have to use the {\em manual mode} to trigger 
-load balancer themselves. The API is described below.
-
-%A few notes about {\em ResumeFromSync()}\footnote{It used to 
-%only work in automatic with sync mode.}. It can be used in all above three
-%load balancing modes. For an array element(whether it is migrated or not), 
-%it is more like getting a notification from load
-%balancer about the completeness of load balancing phase.
-%Users can choose to handle it by writing their own
-%code for {\em ResumeFromSync()}, or just ignore it. The proper use of both 
-%{\em AtSync()} and {\em ResumeFromSync()} gives you the effect of 
-%load balancing barrier. 
+The load balancing framework is well integrated with chare array implementation
+-- when a chare array is created, it automatically registers its elements with
+the load balancing framework. The instrumentation of compute time (wall/cpu
+time) and communication pattern are done automatically and APIs are provided
+for users to trigger the load balancing.  To use the load balancer, you must
+make your array elements migratable (see migration section above) and choose a
+\kw{load balancing strategy} (see the section \ref{lbStrategy} for a
+description of available load balancing strategies).
+
+There are three different ways to use load balancing for chare arrays to meet
+different needs of the applications. These methods are different in how and
+when a load balancing phase starts. The three methods are: {\bf periodic load
+balancing mode}, {\bf at sync mode} and {\bf manual mode}.
+
+In {\em periodic load balancing mode}, a user just needs to specify how often
+he wants the load balancing to occur, using +LBPeriod runtime option to specify
+a time interval.
+
+In {\em sync mode}, users can tell the load balancer explicitly when is a good
+time to trigger load balancing by inserting a function call (AtSync) in the
+user code.
+
+In the above two load balancing modes, users do not need to worry about how to
+start load balancing.  However, in one scenario, the above automatic load
+balancers will fail to work - when array elements are created by dynamic insertion.
+This is because the above two load balancing modes require an application to
+have fixed number of objects at the time of load balancing.  The array manager
+needs to maintain a head count of local array elements for the local barrier.
+In this case, users have to use the {\em manual mode} to trigger load balancer
+themselves.
 
 The detailed APIs of these three methods are described as follows:
+%
 \begin{enumerate}
-
-\item {\bf periodical load balancing mode}: By default, the array elements 
-may be asked to migrate at any time provided that they are not in 
-the middle of executing an entry method. 
-The array element's variable \kw{usesAtSync} being CmiFalse attributes
-to this default behavior. In the default setting, load balancing happens
-whenever the array elements are ready with interval of 1 second. It is 
-desirable for the application to set a larger interval using +LBPeriod
-runtime option. For example "+LBPeriod 5" to start load balancing roughly
-every 5 seconds.
-
-\item {\bf automatic with Sync}: Using the AtSync method, elements can 
-only be migrated at certain points in the execution when user calls 
-\kw{AtSync()}. 
-For the AtSync method, set \kw{usesAtSync} to CmiTrue in your 
-array element constructor.  When an element is ready to migrate,
-call \kw{AtSync()}~\footnote{AtSync() is a member function of class ArrayElement}.  
-When all local elements call \kw{AtSync}, the load balancer is triggered.  
-Once all migrations are completed, the load balancer calls the 
-virtual function \kw{ArrayElement::ResumeFromSync()} on each of the
-array elements.  
+%
+\item {\bf Periodical load balancing mode}: In the default setting, load
+balancing happens whenever the array elements are ready, with an interval of 1
+second. It is desirable for the application to set a larger interval using
++LBPeriod runtime option. For example "+LBPeriod 5" can be used to start load
+balancing roughly every 5 seconds. By default, array elements may be asked to
+migrate at any time provided that they are not in the middle of executing an
+entry method. The array element's variable \kw{usesAtSync} being CmiFalse
+attributes to this default behavior.
+%
+\item {\bf At sync mode}: Using this method, elements can only be migrated at
+certain points in the execution when user calls \kw{AtSync()}. For using the at
+sync mode, one should set \kw{usesAtSync} to CmiTrue in the array element
+constructor.  When an element is ready to migrate, call
+\kw{AtSync()}~\footnote{AtSync() is a member function of class ArrayElement}.
+When all local elements call \kw{AtSync}, the load balancer is triggered.  Once
+all migrations are completed, the load balancer calls the virtual function
+\kw{ArrayElement::ResumeFromSync()} on each of the array elements. This
+function can be redefined in the application.
 
 Note that {\em AtSync()} is not a blocking call, it just gives a hint to load
-balancing that it is time for load balancing. During the time between 
-{\em AtSync} and {\em ResumeFromSync}, the object may be migrated. 
-One can choose to let objects continue working with incoming messages,
-however keep in mind the object may suddenly show up in another processor
-and make sure no operations that could possibly prevent migration 
-be performed. The most commonly used approach is to force the object to 
-be idle until load balancing finishes, the object can start working again
-when \kw{ResumeFromSync()} is called.
-
-\item {\bf manual mode}: The load balancer can be programmed to be started
-manually. To switch to the manual mode, you should call
-{\em TurnManualLBOn()} on every processor to prevent load balancer from 
-starting automatically. {\em TurnManualLBOn()} should be called as 
-early as possible in the program. It could be called at the initialization 
-part of the program, 
-for example from a global variable constructor, or in an initcall~\ref{initcall}.
-It can also be called in the constructor of a static array and
-definitely before the {\em doneInserting} call for a dynamic array.  
-It can be called multiple times on one 
-processor, but only the last one takes effect.
-
-The function call {\em StartLB()} starts load balancing immediately. 
-This call should be made at only one place on only one processor.
-This function is also not blocking, the object will continue to process
-messages and the load balancing when triggered
-happens at the background.
-
-{\em TurnManualLBOff()} turns off manual load balancing and 
-switches back to the automatic Load balancing mode.
-
+balancing that it is time for load balancing. During the time between {\em
+AtSync} and {\em ResumeFromSync}, the object may be migrated. One can choose
+to let objects continue working with incoming messages, however keep in mind
+the object may suddenly show up in another processor and make sure no
+operations that could possibly prevent migration be performed. This is the automatic way of doing load balancing where the application does not need to define ResumeFromSync().
+
+The more commonly used approach is to force the object to be idle until load
+balancing finishes. The user places an AtSync call at the end of some iteration
+and when all elements reach that call load balancing is triggered. The objects
+can start executing again when \kw{ResumeFromSync()} is called. In this case,
+the user redefines ResumeFromSync() to trigger the next iteration of the
+application. This manual way of using the at sync mode results in a barrier at
+load balancing (see example here~\ref{lbexample}).
+%
+\item {\bf Manual mode}: The load balancer can be programmed to be started
+manually. To switch to the manual mode, you should call {\em TurnManualLBOn()}
+on every processor to prevent load balancer from starting automatically. {\em
+TurnManualLBOn()} should be called as early as possible in the program. It
+could be called at the initialization part of the program, for example from a
+global variable constructor, or in an initcall~\ref{initcall}.  It can also be
+called in the constructor of a static array and definitely before the {\em
+doneInserting} call for a dynamic array.  It can be called multiple times on
+one processor, but only the last one takes effect.
+
+The function call {\em StartLB()} starts load balancing immediately. This call
+should be made at only one place on only one processor. This function is also
+not blocking, the object will continue to process messages and the load
+balancing when triggered happens at the background.
+
+{\em TurnManualLBOff()} turns off manual load balancing and switches back to
+the automatic Load balancing mode.
+%
 \end{enumerate}
 
 \subsubsection{Migrating objects}
@@ -482,10 +450,9 @@ As an example, we can collect the data for a 1000 processor run of a program usi
 ./charmrun pgm +p 1000 +balancer RandCentLB +LBDump 2 +LBDumpSteps 4 +LBDumpFile dump.dat
 \end{alltt}
 This will collect data on files data.dat.{2,3,4,5}. Then, we can use this data to observe various centralized strategies using:
-\begin{verbatim}
-./charmrun pgm +balancer <Strategy to test> +LBSim 2 +LBSimSteps 4 
-               +LBDumpFile dump.dat [+LBSimProcs 900]
-\end{verbatim}
+\begin{alltt}
+./charmrun pgm +balancer <Strategy to test> +LBSim 2 +LBSimSteps 4 +LBDumpFile dump.dat [+LBSimProcs 900]
+\end{alltt}
 
 \subsubsection{Future load predictor}
 
@@ -496,7 +463,7 @@ function to the load balancer to predict what will be the future workload, given
 the past, instrumented one. As said, the user might provide a specific class
 which inherits from {\tt LBPredictorFunction} and implement the appropriate functions. 
 Here is the abstract class:
-\begin{verbatim}
+\begin{alltt}
 class LBPredictorFunction {
 public:
   int num_params;
@@ -504,10 +471,10 @@ public:
   virtual void initialize_params(double *x);
 
   virtual double predict(double x, double *params) =0;
-  virtual void print(double *params) {PredictorPrintf("LB: unknown model\n");};
+  virtual void print(double *params) {PredictorPrintf("LB: unknown model");};
   virtual void function(double x, double *param, double &y, double *dyda) =0;
 };
-\end{verbatim}
+\end{alltt}
 \begin{itemize}
 \item {\tt initialize\_params} by default initializes the parameters randomly. If the user
 knows how they should be, this function can be reimplemented.
@@ -657,11 +624,12 @@ name used above. Now one can use {\bf -balance foo} as compile time option
 to {\bf charmc} to link with the {\em foo} seed load balancer.
 
 \subsubsection{Simple Load Balancer Usage Example - Automatic with Sync LB}
-
 \label{lbexample}
-A simple example of how to use a load balancer in sync mode in one's application is presented below.
 
-\begin{verbatim}
+A simple example of how to use a load balancer in sync mode in one's
+application is presented below.
+
+\begin{alltt}
 /*** lbexample.ci ***/
 mainmodule lbexample {
   readonly CProxy_Main mainProxy;
@@ -677,9 +645,11 @@ mainmodule lbexample {
     entry void doWork();
   };
 };
-\end{verbatim}
-----------------------------------------------------------------------------------------------------------
-\begin{verbatim}
+\end{alltt}
+
+--------------------------------------------------------------------------------
+
+\begin{alltt}
 /*** lbexample.C ***/
 #include <stdio.h>
 #include "lbexample.decl.h"
@@ -708,7 +678,7 @@ public:
   {
     count++;
     if(count==nElements){
-      CkPrintf("All done\n");
+      CkPrintf("All done");
       CkExit();
     }
   };
@@ -745,7 +715,7 @@ public:
     if(workcnt==MAX_WORK_CNT)
       mainProxy.done();
     
-    if(workcnt%LB_INTERVAL==0)
+    if(workcnt\%LB_INTERVAL==0)
       AtSync();
     else
       doWork();
@@ -757,4 +727,4 @@ public:
 };
 
 #include "lbexample.def.h"
-\end{verbatim}
+\end{alltt}
index e55a5655b32581178e68e99fdbdb6dbda6a8d267..b97e119c93ea063e68745d8c2190d19cfdc6175c 100644 (file)
@@ -1,6 +1,7 @@
 \documentclass[10pt]{article}
 
 \usepackage{../pplmanual} \input{../pplmanual} \usepackage{html}
+\usepackage{listings}
 \title{The\\ \charmpp\\ Programming Language\\ Manual} \version{6.0
   (Release 1)} \credits{ {\small The Charm software was developed as a
     group effort.  The earliest prototype, Chare Kernel(1.0), was
@@ -74,6 +75,7 @@
   \input{entry}
   \input{marshalling}  
   \input{messages}
+  \input{order.tex}
   \input{chares}
   \input{readonly}    
   \input{arrays}
@@ -92,6 +94,8 @@
   \input{python}
 \input{inhertmplt}
 
+\input{msa.tex}
+
 \input{checkpoint}
 
 \input{controlpoints}
index 47f0868839c003b851050d15f6c85aa3a59e611f..a937e69e66eaaaa58c2feb508ad25b4f2d726275 100644 (file)
@@ -476,172 +476,13 @@ itself should be declared to be a flat struct.  This will allow the \CC\
 compiler to ensure proper alignment of all its member fields.
 
 
-\subsubsection{Prioritized Execution}
-
-\label{prioritized message passing}
-\index{prioritized execution}
-\index{prioritized message passing}
-\index{priorities}
-
-By default, \charmpp\ will process the messages you send in roughly
-FIFO\index{message delivery order} order.  For most programs, this
-behavior is fine.  However, some programs need more explicit control
-over the order in which messages are processed.  \charmpp\ allows you
-to control queueing behavior on a per-message basis.
-
-The simplest call available to change the order in which messages
-are processed is \kw{CkSetQueueing}.
-
-\function{void CkSetQueueing(MsgType message, int queueingtype)}
-
-where \uw{queueingtype} is one of the following constants:
-
-\begin{alltt}
-  CK_QUEUEING_FIFO
-  CK_QUEUEING_LIFO
-  CK_QUEUEING_IFIFO
-  CK_QUEUEING_ILIFO
-  CK_QUEUEING_BFIFO
-  CK_QUEUEING_BLIFO
-\end{alltt}
-
-The first two options,  \kw{CK\_QUEUEING\_FIFO} and
-\kw{CK\_QUEUEING\_LIFO}, are used as follows: 
-
-\begin{alltt}
-  MsgType *msg1 = new MsgType ;
-  CkSetQueueing(msg1, CK_QUEUEING_FIFO);
-
-  MsgType *msg2 = new MsgType ;
-  CkSetQueueing(msg2, CK_QUEUEING_LIFO);
-\end{alltt}
-
-When message \kw{msg1} arrives at its destination, it will be pushed onto the
-end of the message queue as usual.  However, when \kw{msg2} arrives, it will be
-pushed onto the {\em front} of the message queue.
-
-The other four options involve the use of priorities\index{priorities}.  To
-attach a priority field to a message, one needs to set aside space in the
-message's buffer while allocating the message\index{message priority}.  To
-achieve this, the size of the priority field\index{priority field} in bits
-should be specified as a placement argument to the \kw{new} operator, as
-described in Section \ref{memory allocation}.  Although the size of the
-priority field is specified in bits, it is always padded to an integral number
-of {\tt int}s.  A pointer to the priority part of the message buffer can be
-obtained with this call:
-
-\function{void *CkPriorityPtr(MsgType msg)}
-\index{CkPriorityPtr}
-\index{priority pointer}
-
-There are two kinds of priorities which can be attached to a message: {\sl
-integer priorities}\index{integer priorities} and {\sl bitvector
-priorities}\index{bitvector priorities}.  Integer priorities are quite
-straightforward.  One allocates a message with an extra integer parameter to
-``new'' (see the first line of the example below), which sets aside enough
-space (in bits) in the message to hold the priority.  One then stores the
-priority in the message.  Finally, one informs the system that the message
-contains an integer priority using \kw{CkSetQueueing}:
-
-\begin{alltt}
-  MsgType *msg = new (8*sizeof(int)) MsgType;
-  *(int*)CkPriorityPtr(msg) = prio;
-  CkSetQueueing(msg, CK_QUEUEING_IFIFO);
-\end{alltt}
-
-The predefined constant  \kw{CK\_QUEUEING\_IFIFO} indicates that the
-message contains an integer priority, and that if there are other
-messages of the same priority, they should be sequenced in FIFO order
-(relative to each other).  Similarly, a  \kw{CK\_QUEUEING\_ILIFO} is
-available.  Note that  \kw{MAXINT} is the lowest priority, and {\bf
-NEGATIVE\_MAXINT} is the highest priority\index{integer priority range}.
-
-Bitvector priorities are somewhat more complicated.  Bitvector
-priorities are arbitrary-length bit-strings representing fixed-point
-numbers in the range 0 to 1.  For example, the bit-string ``001001''
-represents the number .001001\raisebox{-.5ex}{\scriptsize binary}.  As
-with the simpler kind of priority, higher numbers represent lower
-priorities.  Unlike the simpler kind of priority, bitvectors can be of
-arbitrary length, therefore, the priority numbers they represent can
-be of arbitrary precision.
-
-Arbitrary-precision priorities\index{arbitrary-precision priorities}
-are often useful in AI search-tree applications.  Suppose we have a
-heuristic suggesting that tree node $N_1$ should be searched before
-tree node $N_2$.  We therefore designate that node $N_1$ and its
-descendants will use high priorities, and that node $N_2$ and its
-descendants will use lower priorities.  We have effectively split the
-range of possible priorities in two.  If several such heuristics fire
-in sequence, we can easily split the priority range \index{priority
-range splitting} in two enough times that no significant bits remain,
-and the search begins to fail for lack of meaningful priorities to
-assign.  The solution is to use arbitrary-precision priorities,
-i.e. bitvector priorities.
-
-To assign a bitvector priority, two methods are available.  The
-first is to obtain a pointer to the priority field using  \kw{CkPriorityPtr},
-and to then manually set the bits using the bit-setting operations
-inherent to C.  To achieve this, one must know the format
-\index{bitvector format} of the
-bitvector, which is as follows: the bitvector is represented as an
-array of unsigned integers.  The most significant bit of the first
-integer contains the first bit of the bitvector.  The remaining bits
-of the first integer contain the next 31 bits of the bitvector.
-Subsequent integers contain 32 bits each.  If the size of the
-bitvector is not a multiple of 32, then the last integer contains 0
-bits for padding in the least-significant bits of the integer.
-
-The second way to assign priorities is only useful for those who are
-using the priority range-splitting\index{priority range splitting}
-described above.  The root of the tree is assigned the null
-priority-string.  Each child is assigned its parent's priority with
-some number of bits concatenated.  The net effect is that the entire
-priority of a branch is within a small epsilon of the priority of its
-root.
-
-It is possible to utilize unprioritized messages, integer priorities,
-and bitvector priorities in the same program.  The messages will be
-processed in roughly the following order\index{multiple priority types}:
-
-\begin{itemize}
-
-\item Among messages enqueued with bitvector priorities, the
-messages are dequeued according to their priority.  The
-priority ``0000...'' is dequeued first, and ``1111...'' is
-dequeued last.
-
-\item Unprioritized messages are treated as if they had the
-priority ``1000...'' (which is the ``middle'' priority, it
-lies exactly halfway between ``0000...'' and ``1111...'').
-\item Integer priorities are converted to bitvector priorities.  They
-are normalized so that the integer priority of zero is converted to
-``1000...'' (the ``middle'' priority).  To be more specific, the
-conversion is performed by adding 0x80000000 to the integer, and then
-treating the resulting 32-bit quantity as a 32-bit bitvector priority.
-
-\item Among messages with the same priority, messages are
-dequeued in FIFO order or LIFO order, depending upon which
-queuing strategy was used.
-
-\end{itemize} 
-
-A final warning about prioritized execution: \charmpp\ always processes
-messages in {\it roughly} the order you specify; it never guarantees to
-deliver the messages in {\it precisely} the order\index{message
-delivery order} you specify.
-However, it makes a serious attempt to be ``close'', so priorities
-can strongly affect the efficiency of your program.
-
 
 \subsubsection{Immediate Messages}
 
-Immediate messages are specical messages that skip the Charm scheduler, they
+Immediate messages are special messages that skip the Charm scheduler, they
 can be executed in an ``immediate'' fashion even in the middle of 
 a normal running entry method. 
 They are supported only in nodegroup.
-Also see Section~\ref{attributes} and example in {\it charm/pgms/charm++/megatest/immediatering.C}.
-
 
 
 
diff --git a/doc/charm++/msa.tex b/doc/charm++/msa.tex
new file mode 100644 (file)
index 0000000..c47f1ad
--- /dev/null
@@ -0,0 +1,171 @@
+\section{Multiphase Shared Arrays}
+\label{msa}
+
+Charm++ includes \emph{multiphase shared arrays} (MSA), a distributed
+shared array library designed to safely enable common patterns of
+shared-memory scientific applications while retaining the benefits of
+an asynchronous adaptive runtime system. The general pattern of usage
+that MSA supports is one in which the application does one sort of
+access on an array for a while, and then changes to another kind of
+access at some distinguished point in the execution. For instance, one
+part of the program might accumulate a physical quanitity onto a grid
+representing the simulation space, and another part might read from
+that grid once it is fully calculated.
+
+MSA formalizes this pattern in its access modes and phases. This
+formality allows the runtime to optimize data movement and exclude
+race conditions and other hard-to-debug errors that can be common in
+shared-array programming.
+
+Development on MSA is ongoing. This means that its API may not be
+completely stable, but it also means that its developers are actively
+seeking suggestions of new use cases and features. At present, it is
+generic over element type, and supports 1, 2, and 3 dimensional
+rectangular arrays with row- and column-major element orderings.
+
+\subsection{Access Modes}
+
+At any given time, each MSA is in a particular \emph{access mode} that
+allows one kind of operation on the array. At present, MSA defines the
+following access modes:
+
+\begin{description}
+\item[Read-Only Mode]
+As its name suggests, read-only mode makes the array immutable,
+permitting reads of any element but writes to none.
+E.g. {\tt x = r(i, j, k);}
+
+\item[Write-Once Mode]
+MSA's write mode allows only direct assignment of values to elements
+of the array. E.g. {\tt w(i, j) = y;}
+
+When assigning values to elements of a shared array, the primary
+safety concern is write-after-write conflicts, in which some
+particular entry is assigned twice, possibly by different parallel
+entities. MSA checks for conflicting assignments at
+runtime\footnote{When {\tt CMK\_ERROR\_CHECKING} is defined}, and will
+raise an error on detection.
+
+\item[Accumulate Mode]
+
+Accumulation is the application of a commutative associative operator,
+such as addition or multiplication, to some entry in an
+array. E.g. {\tt a(i) += z;}. MSA allows arbitrary user-defined
+accumulation operations, including things like set union.
+
+Frequently, applications do a set of read-modify-write accesses across
+all or parts of a shared array. When the modification is an
+accumulation, the code that has the value to be contributed needn't
+actually read the current value, as long as all contributions to each
+element are accounted for before the next read from that element. As
+we will see, MSA's structure ensures that this is the case, without
+requiring atomic remote operations or locking.
+
+\end{description}
+
+To provide the guarantees described above, MSA requires that clients
+of an array collectively synchronize when they wish to change the mode
+in which the array will be accessed. Each period between
+synchronizations is called a \emph{phase}. At phase boundaries, writes
+are flushed and accumulations are totalled up.
+
+MSA enforces most of the restrictions of its access modes discipline
+at compile time through the static types of \emph{handle}
+objects. During a phase, each client of an array will hold an
+appropriately typed handle to that array, presenting only the allowed
+operations in its interface. At synchronization, clients ``trade in''
+the old handle to be invalidated, and receive a new one representing
+the array's mode for the upcoming phase.
+
+\subsection{Declaration and construction}
+
+The MSA package is defined as a set of C++ templates that make it
+generic over the type of its elements and the accumulation operation.
+The templates are named {\tt MSAKD<>}, where K is the number of
+dimensions in the array, and the template arguments are the contained
+type and a class defining the desired accumulation operator:
+
+\begin{verbatim}
+template<class ENTRY, class ENTRY_OPS_CLASS>
+class MSAKD { ... };
+\end{verbatim}
+
+The second argument must be a class (or class template) meeting the
+following interface for the corresponding type {\tt ENTRY}:
+\begin{verbatim}
+struct entry_ops {
+  /// Accumulate b into element a
+  static void accumulate(ENTRY &a, const ENTRY &b);
+  /// An identity value for the accumulate operation
+  static ENTRY getIdentity();
+  /// Should the MSA PUP its elements when shipping them around?
+  static bool pupEveryElement();
+};
+\end{verbatim}
+The library provides templated implementations of this interface for
+addition, multiplication, and maximum. See the MSA headers for details
+on these classes.
+
+When constructing an MSA, the application must specify the extent of
+the array in each dimension and the number of clients that will access
+the array (so that the library can tell when all clients ahve
+synchronized). The array creation constructors are as follows:
+\begin{verbatim}
+/// Indices range over [0, N]
+MSA1D(unsigned int num_entries, unsigned int num_workers);
+MSA2D(unsigned int rows, unsigned int cols, unsigned int num_workers);
+MSA3D(unsigned int x, unsigned int y, unsigned int z, unsigned int num_workers);
+/// Indices range over [da, db]
+MSA3D(int xa, int xb, int ya, int yb, int za, int zb, unsigned int num_wrkrs);
+\end{verbatim}
+At construction, the array is filled with its identity element.
+
+After construction, each client must call the {\tt enroll()} method on
+a copy of the MSA object. These clients must run all code operating on
+the MSA in a user-level thread, via entry methods with the {\tt
+  [threaded]} attribute, AMPI ranks, or explicitly created {\sc
+  TCharm} threads.
+
+Once enrollment is complete, each of the clients can get a handle to
+enter data into the array:
+\begin{verbatim}
+MYMSA::Write wMymsa = mymsa.getInitialWrite();
+// or
+MYMSA::Accum aMymsa = mymsa.getInitialAccum();
+\end{verbatim}
+
+When a client is done with its work on an array in a phase, it must
+call a synchronization method on its handle. If it will operate on the
+array in the next phase, it asks for a new handle, and if it won't, it
+simply indicates that it's done:
+\begin{verbatim}
+MYMSA::Read rMymsa = aMymsa.syncToRead();
+MYMSA::Write wMymsa = rMymsa.syncToWrite();
+MYMSA::Accum aMymsa = wMymsa.syncToAccum();
+aMymsa.syncDone();
+\end{verbatim}
+All clients must synchronize to the same mode in each phase. If the
+array sees clients synchronizing into different modes, it will raise
+an error at runtime.
+
+\subsection{MSA Usage Example}
+
+The constructs described so far are demonstrated in this example
+implementation of a parallel distributed $k$-means clustering
+algorithm:
+
+\lstset{language=c++, commentstyle=\textit, emphstyle=\textbf,
+  numbers=left, keywordstyle=, label=lst:kmeans, captionpos=b,
+  basicstyle=\small\tt,
+%
+caption={Parallel $k$-Means Clustering implemented using an MSA named
+  \textbf{clusters}. This function is run in a thread on every
+  processor. First, processors selected as initial `seeds' write their
+  locations into the array (call on line 5). Then, all the processors
+  iterate finding the closest seed (lines 14--20) and moving
+  themselves into it (22--33). They all test for convergence by
+  checking an entry indicating whether any processor moved (37). }
+%
+}
+\lstinputlisting{kmeans.cpp}
+
index 3f77718717ddbba1f9c5e0ed2732c5884925a7b5..057ad8259c4d671354e7df890faadd3b28d62a4c 100644 (file)
@@ -76,15 +76,11 @@ node may execute any other {\em exclusive} method of that
 execute other {\em non-exclusive} methods of that nodegroup
 \index{branch}branch, however.
 
-The local \index{branch}branch of a \kw{nodegroup} can be accessed using
-\kw{CkLocalNodeBranch()} function. Thus data members could be accessed/modified
-or methods could be invoked on a \index{branch}branch of a \kw{nodegroup} using
-this function. Note that such accesses are {\em not} thread-safe by default.
-Concurrent invocation of a method on a \index{nodegroup}nodegroup by different
-processors within a node may result in unpredictable runtime behavior.  One way
-to avoid this is to use node-level locks (described in Converse manual.)
-
-\kw{CkLocalNodeBranch} returns a generic ({\tt void *}) pointer, similar to
-\kw{CkLocalBranch}.  Also, the static method \kw{ckLocalNodeBranch} of the
-proxy class of appropriate \index{nodegroup}nodegroup can be called to get the
-correct type of pointer.
+The local \index{branch}branch of a \kw{nodegroup} \uw{NG}, and hence
+its member fields and methods, can be accessed through the method
+\kw{NG* CProxy\_NG::ckLocalBranch()} of its proxy. Note that such
+accesses are {\em not} thread-safe by default.  Concurrent invocation
+of a method on a \index{nodegroup}nodegroup by different processors
+within a node may result in unpredictable runtime behavior.  One way
+to avoid this is to use node-level locks (described in Converse
+manual.)
diff --git a/doc/charm++/order.tex b/doc/charm++/order.tex
new file mode 100644 (file)
index 0000000..755d9b0
--- /dev/null
@@ -0,0 +1,202 @@
+\subsection{Delivery Order}
+
+By default, \charmpp\ will process the messages you send in roughly
+FIFO\index{message delivery order} order when they arrive at a PE.
+For most programs, this behavior is fine.  However, for optimal
+performance, some programs need more explicit control over the order
+in which messages are processed. \charmpp\ allows you to adjust
+delivery order on a per-message basis.
+
+% Example general use cases here
+
+\subsubsection{Queueing Strategies}
+\label{queueing strategies}
+
+The simplest call available to change the order in which messages
+are processed is \kw{CkSetQueueing}.
+
+\function{void CkSetQueueing(MsgType message, int queueingtype)}
+
+where \uw{queueingtype} is one of the following constants:
+
+\begin{alltt}
+  CK_QUEUEING_FIFO
+  CK_QUEUEING_LIFO
+  CK_QUEUEING_IFIFO
+  CK_QUEUEING_ILIFO
+  CK_QUEUEING_BFIFO
+  CK_QUEUEING_BLIFO
+\end{alltt}
+
+The first two options,  \kw{CK\_QUEUEING\_FIFO} and
+\kw{CK\_QUEUEING\_LIFO}, are used as follows:
+
+\begin{alltt}
+  MsgType *msg1 = new MsgType ;
+  CkSetQueueing(msg1, CK_QUEUEING_FIFO);
+
+  MsgType *msg2 = new MsgType ;
+  CkSetQueueing(msg2, CK_QUEUEING_LIFO);
+
+  CkEntryOptions opts1, opts2;
+  opts1.setQueueing(CK_QUEUEING_FIFO);
+  opts2.setQueueing(CK_QUEUEING_LIFO);
+
+  chare.entry_name(arg1, arg2, opts1);
+  chare.entry_name(arg1, arg2, opts2);
+\end{alltt}
+
+When message \kw{msg1} arrives at its destination, it will be pushed
+onto the end of the message queue as usual.  However, when \kw{msg2}
+arrives, it will be pushed onto the {\em front} of the message
+queue. Similarly, the two parameter-marshalled calls to \kw{chare}
+will be inserted at the end and beginning of the message queue,
+respectively.
+
+\subsubsection{Prioritized Execution}
+\label{prioritized message passing}
+\index{prioritized execution}
+\index{prioritized message passing}
+\index{priorities}
+
+The basic FIFO and LIFO strategies are sufficient to approximate
+parallel breadth-first and depth-first explorations of a problem
+space, but they don't admit more fine-grained control. To provide that
+degree of control, \charmpp\ also allows explicit prioritization of
+messages.
+
+The other four queueing strategies involve the use of
+priorities\index{priorities}.  There are two kinds of priorities which
+can be attached to a message: {\sl integer priorities}\index{integer
+  priorities} and {\sl bitvector priorities}\index{bitvector
+  priorities}. These correspond to the {\em I} and {\em B} queueing
+strategies, respectively. In both cases, numerically lower priorities
+will be dequeued and delivered before numerically greater
+priorities. The FIFO and LIFO queueing strategies then control the
+relative order in which messages of the same priority will be
+delivered.
+
+To attach a priority field to a
+message, one needs to set aside space in the message's buffer while
+allocating the message\index{message priority}.  To achieve this, the
+size of the priority field\index{priority field} in bits should be
+specified as a placement argument to the \kw{new} operator, as
+described in Section \ref{memory allocation}.  Although the size of
+the priority field is specified in bits, it is always padded to an
+integral number of {\tt int}s.  A pointer to the priority part of the
+message buffer can be obtained with this call:
+
+\function{void *CkPriorityPtr(MsgType msg)}
+\index{CkPriorityPtr}
+\index{priority pointer}
+
+Integer priorities are quite straightforward.  One allocates a message
+with an extra integer parameter to ``new'' (see the first line of the
+example below), which sets aside enough space (in bits) in the message
+to hold the priority.  One then stores the priority in the message.
+Finally, one informs the system that the message contains an integer
+priority using \kw{CkSetQueueing}:
+
+\begin{alltt}
+  MsgType *msg = new (8*sizeof(int)) MsgType;
+  *(int*)CkPriorityPtr(msg) = prio;
+  CkSetQueueing(msg, CK_QUEUEING_IFIFO);
+\end{alltt}
+
+Integer proiorities for parameter-marshalled messages can be achieved
+through {\tt CkEntryOptions::setPriority()}:
+
+\begin{alltt}
+  CkEntryOptions opts;
+  opts.setPriority(7);
+  chare.entry_name(arg1, arg2, opts);
+\end{alltt}
+
+Bitvector priorities are somewhat more complicated.  Bitvector
+priorities are arbitrary-length bit-strings representing fixed-point
+numbers in the range 0 to 1.  For example, the bit-string ``001001''
+represents the number .001001\raisebox{-.5ex}{\scriptsize binary}.  As
+with the simpler kind of priority, higher numbers represent lower
+priorities.  Unlike the simpler kind of priority, bitvectors can be of
+arbitrary length, therefore, the priority numbers they represent can
+be of arbitrary precision.
+
+Arbitrary-precision priorities\index{arbitrary-precision priorities}
+are often useful in AI search-tree applications.  Suppose we have a
+heuristic suggesting that tree node $N_1$ should be searched before
+tree node $N_2$.  We therefore designate that node $N_1$ and its
+descendants will use high priorities, and that node $N_2$ and its
+descendants will use lower priorities.  We have effectively split the
+range of possible priorities in two.  If several such heuristics fire
+in sequence, we can easily split the priority range \index{priority
+range splitting} in two enough times that no significant bits remain,
+and the search begins to fail for lack of meaningful priorities to
+assign.  The solution is to use arbitrary-precision priorities,
+i.e. bitvector priorities.
+
+To assign a bitvector priority, two methods are available.  The
+first is to obtain a pointer to the priority field using  \kw{CkPriorityPtr},
+and to then manually set the bits using the bit-setting operations
+inherent to C.  To achieve this, one must know the format
+\index{bitvector format} of the
+bitvector, which is as follows: the bitvector is represented as an
+array of unsigned integers.  The most significant bit of the first
+integer contains the first bit of the bitvector.  The remaining bits
+of the first integer contain the next 31 bits of the bitvector.
+Subsequent integers contain 32 bits each.  If the size of the
+bitvector is not a multiple of 32, then the last integer contains 0
+bits for padding in the least-significant bits of the integer.
+
+The second way to assign priorities is only useful for those who are
+using the priority range-splitting\index{priority range splitting}
+described above.  The root of the tree is assigned the null
+priority-string.  Each child is assigned its parent's priority with
+some number of bits concatenated.  The net effect is that the entire
+priority of a branch is within a small epsilon of the priority of its
+root.
+
+It is possible to utilize unprioritized messages, integer priorities,
+and bitvector priorities in the same program.  The messages will be
+processed in roughly the following order\index{multiple priority types}:
+
+\begin{itemize}
+
+\item Among messages enqueued with bitvector priorities, the
+messages are dequeued according to their priority.  The
+priority ``0000...'' is dequeued first, and ``1111...'' is
+dequeued last.
+
+\item Unprioritized messages are treated as if they had the
+priority ``1000...'' (which is the ``middle'' priority, it
+lies exactly halfway between ``0000...'' and ``1111...'').
+
+\item Integer priorities are converted to bitvector priorities.  They
+are normalized so that the integer priority of zero is converted to
+``1000...'' (the ``middle'' priority).  To be more specific, the
+conversion is performed by adding 0x80000000 to the integer, and then
+treating the resulting 32-bit quantity as a 32-bit bitvector priority.
+
+\item Among messages with the same priority, messages are
+dequeued in FIFO order or LIFO order, depending upon which
+queuing strategy was used.
+
+\end{itemize}
+
+A final reminder about prioritized execution: \charmpp\ processes
+messages in {\it roughly} the order you specify; it never guarantees
+that it will deliver the messages in {\it precisely} the
+order\index{message delivery order} you specify. Thus, the correctness
+of your program should never depend on the order in which the runtime
+delivers messages. However, it makes a serious attempt to be
+``close'', so priorities can strongly affect the efficiency of your
+program.
+
+\subsubsection{Skipping the Queue}
+
+Some operations that one might want to perform are sufficiently
+latency-sensitive that they should never wait in line behind other
+messages. The \charmpp\ runtime offers two attributes for entry
+methods, {\kw expedited} and {\kw immediate}, to serve these
+needs. For more information on these attributes, see
+Section~\ref{attributes} and the example in {\tt
+  charm/pgms/charm++/megatest/immediatering.C}.
diff --git a/examples/bigsim/tools/text2log/Makefile b/examples/bigsim/tools/text2log/Makefile
new file mode 100644 (file)
index 0000000..5fb0031
--- /dev/null
@@ -0,0 +1,20 @@
+OPTS = -g
+CHARMC=../../../../bin/charmc $(OPTS)
+
+all: text2log
+
+text2log: text2log.o
+       $(CHARMC) -seq -o text2log text2log.o -lconv-bigsim-logs -lconv-util -lblue-standalone -language c++
+
+text2log.o: text2log.C 
+       $(CHARMC) -seq -c text2log.C
+
+clean:
+       rm -f *.o text2log *~ moduleinit.C charmrun conv-host
+       rm -rf *.decl.h *.def.h core *.log
+
+help: text2log
+       ./text2log -help
+
+test: text2log
+       ./text2log 1 1 1 1 1 1
diff --git a/examples/bigsim/tools/text2log/README b/examples/bigsim/tools/text2log/README
new file mode 100644 (file)
index 0000000..1c79510
--- /dev/null
@@ -0,0 +1,7 @@
+This tool converts a set of ASCII log#.txt files to binary bgTrace files.  Run the tool with -help for more info.
+
+While text2log does a lot of checks to ensure the output trace files are valid and can be run in BigNetSim, it may miss a few obscure cases, such as with certain parts of stand-alone events.
+
+Examples can be found in the examples.tgz tarball.  The log#.txt files are the input, the bgTrace* files are the binary output traces, and the detail* files are ASCII dumps of the bgTrace files using the LogAnalyzer tool from the BigNetSim archive.
+
+The eventTemplates.txt file contains simple fill-in-the-blank templates for events and messages that can be easily copied and pasted to create new log#.txt files.
diff --git a/examples/bigsim/tools/text2log/eventTemplates.txt b/examples/bigsim/tools/text2log/eventTemplates.txt
new file mode 100644 (file)
index 0000000..c85661f
--- /dev/null
@@ -0,0 +1,64 @@
+Set the times, set fields with <>s in them, and fill in any remaining blank fields after the colons.
+
+==================================================
+                    Messages
+==================================================
+
+Standard unicast
+----------------
+-msgID: sent:0.000000 recvtime:0.000000 dstNode: tid: size: group:1
+
+
+Broadcast-all
+-------------
+-msgID: sent:0.000000 recvtime:0.000000 dstNode:-1 tid:-1 size: group:1
+
+
+Broadcast-all-except node N
+---------------------------
+-msgID: sent:0.000000 recvtime:0.000000 dstNode:<-100-N> tid:-1 size: group:1
+
+
+Broadcast-all-except core K of node N
+-------------------------------------
+-msgID: sent:0.000000 recvtime:0.000000 dstNode:<-100-N> tid:<K> size: group:1
+
+
+Multicast of X messages with message ID M
+-----------------------------------------
+-msgID:<M> sent:0.000000 recvtime:0.000000 dstNode: tid: size: group:<X>
+-msgID:<M> sent:0.000000 recvtime:0.000000 dstNode: tid: size: group:-1
+...
+-msgID:<M> sent:0.000000 recvtime:0.000000 dstNode: tid: size: group:-1
+
+
+==================================================
+                     Events
+==================================================
+
+Starting event (event 0 of time line 0)
+---------------------------------------
+[0] name:msgep (srcpe:-1 msgID:-1) ep:-1 charm_ep:-1
+startTime:0.000000 endTime:0.000000
+forward:
+
+
+Standard (dependent)
+--------------------
+[] name: (srcpe:-1 msgID:-1) ep: charm_ep:
+startTime:0.000000 endTime:0.000000
+forward:
+
+
+Message receive
+---------------
+[] name:msgep (srcpe: msgID:) ep: charm_ep:
+startTime:0.000000 endTime:0.000000
+forward:
+
+
+Stand-alone
+-----------
+[] name:addMsg (srcpe:-1 msgID:-1) ep:-1 charm_ep:-1
+startTime:0.000000 endTime:0.000000
+forward:
diff --git a/examples/bigsim/tools/text2log/examples.tgz b/examples/bigsim/tools/text2log/examples.tgz
new file mode 100644 (file)
index 0000000..a3f2397
Binary files /dev/null and b/examples/bigsim/tools/text2log/examples.tgz differ
diff --git a/examples/bigsim/tools/text2log/log0.txt b/examples/bigsim/tools/text2log/log0.txt
new file mode 100644 (file)
index 0000000..01d1d25
--- /dev/null
@@ -0,0 +1,17 @@
+[0] name:Event_0 (srcpe:-1 msgID:-1) ep:-1 charm_ep:-1
+startTime:0.000010 endTime:0.000100
+-msgID:0 sent:0.000050 recvtime:0.000070 dstNode:0 tid:0 size:120 group:1
+-msgID:1 sent:0.000070 recvtime:0.000105 dstNode:-1 tid:-1 size:120 group:1
+forward: [1]
+
+[1] name:Event_1 (srcpe:-1 msgID:-1) ep:0 charm_ep:-1
+startTime:0.000100 endTime:0.000120
+forward:
+
+[2] name:msgep (srcpe:0 msgID:0) ep:1 charm_ep:1
+startTime:0.000120 endTime:0.000150
+forward:
+
+[3] name:msgep (srcpe:0 msgID:1) ep:1 charm_ep:1
+startTime:0.000150 endTime:0.000200
+forward:
diff --git a/examples/bigsim/tools/text2log/text2log.C b/examples/bigsim/tools/text2log/text2log.C
new file mode 100644 (file)
index 0000000..f82fffd
--- /dev/null
@@ -0,0 +1,613 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include "bigsim_logs.h"
+
+// these should be plenty
+#define MAX_MESSAGES 1000000
+#define LINE_SIZE 1024
+
+// pair of ints, used to keep track of forward dependencies
+struct IntPair {
+  int one, two;
+  IntPair() {}
+  IntPair(int unused) {}  // for remove function in CkVec
+  inline void pup(PUP::er &p) {
+    p|one; p|two;
+  }
+};
+
+
+// all the info needed for a message send
+struct MsgSend {
+  int msgID, dstNode, tid, size, group;
+  double sent, recvtime;
+  MsgSend() {}
+  MsgSend(int unused) {}  // for remove function in CkVec
+  inline void pup(PUP::er &p) {
+    p|msgID; p|dstNode; p|tid; p|size;
+    p|group; p|sent; p|recvtime;
+  }
+};
+
+
+int main(int argc, char* argv[]) {
+
+  int numPEs, numNodes, numXNodes, numYNodes, numZNodes, numWth, numTraces;
+
+  /************* Read in command-line parameters *************/
+  if ((argc > 1) && (strcmp(argv[1], "-help") == 0)) {
+    printf("\n");
+    printf("Usage: ./text2log <# log files> <X dim nodes> <Y dim nodes> <Z dim nodes> <# cores/node> [<# emulating procs>]\n");
+    printf("\n");
+    printf("<# log files>  - Integer that specifies the number of log#.txt files to read.\n");
+    printf("                 Each log file must contain exactly one time line.\n");
+    printf("<X dim nodes>  - Integer that specifies the number of simulated nodes in the X dimension.\n");
+    printf("<Y dim nodes>  - Integer that specifies the number of simulated nodes in the Y dimension.\n");
+    printf("<Z dim nodes>  - Integer that specifies the number of simulated nodes in the Z dimension.\n");
+    printf("<# cores/node> - Integer that specifies the number of cores (worker threads) on each simulated node.\n");
+    printf("                 There must be a log#.txt file for every core, and <# nodes> * <# cores/node> must equal the number of log#.txt files.\n");
+    printf("<# emulating procs> - Optional integer that specifies the number of bgTrace files to create.\n");
+    printf("                      If not specified, this number defaults to the number of specified log.txt files.\n");
+    printf("\n");
+    printf("All logs must be of the following format:\n");
+    printf("\n");
+    printf("[<eventNum>] name:<eventName> (srcpe:<srcpe> msgID:<msgID>) ep:<ep> charm_ep:<charm_ep>\n");
+    printf("startTime:<startTime> endTime:<endTime>\n");
+    printf("-msgID:<msgID> sent:<sendTime> recvtime:<recvTime> dstNode:<dstNode> tid:<tid> size:<size> group:<group>\n");
+    printf("forward: <optional list of ints enclosed in []s>\n");
+    printf("\n");
+    printf("Where the message send lines ('-msgID: ...') are optional.  See the examples.tgz tarball for examples.\n");
+    printf("\n");
+    printf("For messages:\n");
+    printf("\n");
+    printf("destNode destTID Behavior\n");
+    printf("======== ======= ==============================================\n");
+    printf("   -1      -1    Broadcast to ALL worker threads of ALL nodes\n");
+    printf("   -2      -1    Multicast to all nodes given by the pe list in the task msg\n");
+    printf("   -1       K    Invalid\n");
+    printf("    N      -1    Send to ALL worker threads of node N\n");
+    printf("    N       K    Send to worker thread K of node N\n");
+    printf(" -100-N    -1    Broadcast to all worker threads of all nodes except for N (no worker threads of N receive)\n");
+    printf(" -100-N     K    Broadcast to all worker threads of all nodes except worker K of node N\n");
+    printf("\n");
+
+    exit(0);
+  }
+
+  if ((argc < 6) || (argc > 7)) {
+    printf("ERROR: there should be 6 or 7 arguments.  Usage: ./text2log <# log files> <X dim nodes> <Y dim nodes> <Z dim nodes> <# cores/node> [<# emulating procs>]\n");
+    printf("Running with -help will provide detailed info on the parameters.\n");
+    exit(-1);
+  }
+
+  numPEs = atoi(argv[1]);
+  numXNodes = atoi(argv[2]);
+  numYNodes = atoi(argv[3]);
+  numZNodes = atoi(argv[4]);
+  numNodes = numXNodes * numYNodes * numZNodes;
+  numWth = atoi(argv[5]);
+  if (argc == 7) {
+    numTraces = atoi(argv[6]);
+  } else {
+    numTraces = numPEs;
+  }
+
+  // command-line parameter sanity checks
+  if (numPEs <= 0) {
+    printf("ERROR: the number of specified log files (%d) must be > 0\n", numPEs);
+    exit(-1);
+  }
+  if (numTraces <= 0) {
+    printf("ERROR: the number of emulating procs (%d) must be > 0\n", numTraces);
+    exit(-1);
+  }
+  if ((numNodes * numWth) != numPEs) {
+    printf("ERROR: the number of nodes * the number of cores per node (%d) must equal the number of specifed log files (%d)\n", 
+          numNodes * numWth, numPEs);
+    exit(-1);
+  }
+  if (numTraces > numNodes) {
+    printf("ERROR: the number of emulating procs (%d) must be <= the number of nodes (%d)\n", numTraces, numNodes);
+    exit(-1);
+  }
+
+  // turn on log generation
+  BgGenerateLogs();
+
+  /************* Read in the log#.txt files and convert them to bgTrace files *************/
+  BgTimeLineRec tlinerecs[numPEs];  // time lines
+  char fileName[20], line[LINE_SIZE];
+  FILE *filePtr;
+  int lineNum, eventCount;
+  BgTimeLog *newLog;
+  BgMsgEntry *newMsg;
+  double lastEndTime;
+  int msgIDsFree[MAX_MESSAGES];
+
+  // event fields
+  int eventNum, srcpe, msgID, ep, charm_ep;
+  char eventName[20];
+  double startTime, endTime;
+
+  CkVec<IntPair> dependencies;
+  CkVec<MsgSend> eventMessages;
+
+  /************* Loop through all log files *************/
+  for (int logNum = 0; logNum < numPEs; logNum++) {
+
+    sprintf(fileName, "log%d.txt", logNum);
+    filePtr = fopen(fileName, "r");
+    if (!filePtr) {
+      printf("Cannot open file %s... exiting.\n", fileName);
+      exit(-1);
+    }
+    printf("Reading file %s...\n", fileName);
+
+    // make msgIDsFree ready to use
+    for (int i = 0; i < MAX_MESSAGES; i++) {
+      msgIDsFree[i] = 1;
+    }
+
+    // clear the dependencies
+    dependencies.clear();
+
+    // read events from the file, one line at a time
+    lineNum = 0;
+    eventNum = 0;
+    eventCount = 0;
+    lastEndTime = 0.0;
+    while (fgets(line, LINE_SIZE, filePtr)) {
+
+      // ignore empty lines
+      if (strcmp(line, "\n") == 0) {
+       lineNum++;
+       continue;
+      }
+
+      // look for the first line of an event, then read the entire event
+      if (line[0] == '[') {
+
+       // first line of event
+       if (sscanf(line, "[%d] name:%s (srcpe:%d msgID:%d) ep:%d charm_ep:%d\n", 
+                  &eventNum, &eventName, &srcpe, &msgID, &ep, &charm_ep) != 6) {
+         printf("ERROR: line %d of file %s not read in properly\n", lineNum, fileName);
+         printf("line=%s\n", line);
+         printf("Looking for the first line of an event with the following format:\n");
+         printf("[<eventNum>] name:<eventName> (srcpe:<srcpe> msgID:<msgID>) ep:<ep> charm_ep:<charm_ep>\n");
+         printf("Where eventNum, srcpe, msgID, ep, and charm_ep are ints, and where eventName is a string no longer than 20 characters\n");
+         exit(-1);
+       }
+       if (eventNum != eventCount) {
+         printf("ERROR: event numbered incorrectly.  Event %d in file %s should be event %d.\n", eventNum, fileName, eventCount);
+         exit(-1);
+       }
+       lineNum++;
+
+       // second line of event
+       if (!fgets(line, LINE_SIZE, filePtr)) {
+         printf("ERROR: line %d of file %s was not read in properly\n", lineNum, fileName);
+         printf("line=%s\n", line);
+         printf("If this line doesn't exist in the file, then please add a 'starTime...' line or delete this event\n");
+         exit(-1);
+       }
+       if (sscanf(line, "startTime:%lf endTime:%lf\n", &startTime, &endTime) != 2) {
+         printf("ERROR: line %d of file %s not read in properly\n", lineNum, fileName);
+         printf("line=%s\n", line);
+         printf("Looking for the second line of an event with the following format:\n");
+         printf("startTime:<startTime> endTime:<endTime>\n");
+         printf("Where startTime and endTime are doubles in seconds\n");
+         exit(-1);
+       }
+       lineNum++;
+
+       // read in messages; skip if they don't exist
+       eventMessages.removeAll();
+       while (fgets(line, LINE_SIZE, filePtr)) {
+         if (line[0] == '-') {
+           MsgSend ms;
+           if (sscanf(line, "-msgID:%d sent:%lf recvtime:%lf dstNode:%d tid:%d size:%d group:%d\n", 
+                      &ms.msgID, &ms.sent, &ms.recvtime, &ms.dstNode, &ms.tid, &ms.size, &ms.group) != 7) {
+             printf("ERROR: line %d of file %s not read in properly\n", lineNum, fileName);
+             printf("line=%s\n", line);
+             printf("Looking for a message send line starting with the following format:\n");
+             printf("-msgID:<msgID> sent:<sendTime> recvtime:<recvTime> dstNode:<dstNode> tid:<tid> size:<size> group:<group>\n");
+             printf("Where msgID, dstNode, tid, size, and group are ints, and sendTime and recvTime are doubles in seconds\n");
+             exit(-1);
+           }
+           eventMessages.insertAtEnd(ms);
+           lineNum++;
+         } else {
+           // no messages left to read, so break out of loop
+           break;
+         }
+       }
+
+       // last line of the event has already been read in
+       if (strncmp(line, "forward:", strlen("forward:")) != 0) {
+         printf("ERROR: line %d of file %s not read in properly\n", lineNum, fileName);
+         printf("line=%s\n", line);
+         printf("Looking for the last line of an event with the following format:\n");
+         printf("forward: <optional list of ints enclosed in []s>\n");
+         printf("For example: 'forward: [4] [13] [27]'\n");
+         exit(-1);
+       }
+       // extract forward dependencies
+       char tempLine[LINE_SIZE];
+       strcpy(tempLine, line + strlen("forward:"));
+       char *token = strtok(tempLine, " []\n");
+       while (token != NULL) {
+         IntPair ip;
+         ip.one = eventNum;
+         ip.two = atoi(token);
+         // ensure forward dependents aren't negative
+         if (ip.two < 0) {
+           printf("ERROR: line %d of file %s contains a negative forward dependent (%d)\n", lineNum, fileName, ip.two);
+           exit(-1);
+         }
+         // ensure forward dependents don't point to their own event
+         if (ip.two == eventNum) {
+           printf("ERROR: event %d at line %d of file %s contains a forward dependent (%d) that points to its own event\n", 
+                  eventNum, lineNum, fileName, ip.two);
+           exit(-1);
+         }
+         dependencies.insertAtEnd(ip);
+         token = strtok(NULL, " []\n");
+       }
+       lineNum++;
+
+      } else {
+       printf("ERROR: Bad log format at line %d of file %s:\n", lineNum, fileName);
+       printf("line=%s\n", line);
+       printf("An event needs to begin with a line with the following format:\n");
+       printf("[<eventNum>] name:<eventName> (srcpe:<srcpe> msgID:<msgID>) ep:<ep> charm_ep:<charm_ep>\n");
+       printf("Where eventNum, srcpe, msgID, ep, and charm_ep are ints, and where eventName is a string no longer than 20 characters\n");
+       exit(-1);
+      }
+
+      /************* Sanity checks *************/
+      // check srcpe and msgID
+      if ((srcpe < -1) || (srcpe > numPEs)) {
+       printf("ERROR: [file %s, event %d] srcpe (%d) must be between -1 and %d, inclusive\n", fileName, eventNum, srcpe, numPEs - 1);
+       exit(-1);
+      }
+      if (msgID < -1) {
+       printf("ERROR: [file %s, event %d] msgID (%d) must be -1 or greater\n", fileName, eventNum, msgID);
+       exit(-1);
+      }
+      if (((srcpe == -1) && (msgID != -1)) || ((msgID == -1) && (srcpe != -1))) {
+       printf("ERROR: [file %s, event %d] if either srcpe (%d) or msgID (%d) is -1, the other must also be -1\n", fileName, eventNum, srcpe, msgID);
+       exit(-1);
+      }
+
+      // check name
+      if ((srcpe >= 0) && (strcmp(eventName, "msgep") != 0)) {
+       printf("WARNING: [file %s, event %d] because the event looks like a message receive, its name should be 'msgep' instead of '%s'\n", 
+              fileName, eventNum, eventName);
+      }
+
+      // check ep and charm_ep
+      if (ep < -1) {
+       printf("ERROR: [file %s, event %d] ep (%d) must be -1 or greater\n", fileName, eventNum, ep);
+         exit(-1);
+      }
+      if (charm_ep < -1) {
+       printf("ERROR: [file %s, event %d] charm_ep (%d) must be -1 or greater\n", fileName, eventNum, charm_ep);
+         exit(-1);
+      }
+
+      // check startTime and endTime
+      if (startTime < lastEndTime) {
+       printf("ERROR: [file %s, event %d] startTime (%lf) must be >= the end time of the last event (%lf)\n", fileName, eventNum, startTime, lastEndTime);
+         exit(-1);
+      }
+      if (endTime < startTime) {
+       printf("ERROR: [file %s, event %d] endTime (%lf) must be >= the startTime of this event (%lf)\n", fileName, eventNum, endTime, startTime);
+         exit(-1);
+      }
+
+      // check each message
+      for (int i = 0; i < eventMessages.length(); i++) {
+       // check the msgID and group
+       if (eventMessages[i].msgID < 0) {
+         printf("ERROR: [file %s, event %d] msgID of message send (%d) must be >= 0\n", fileName, eventNum, eventMessages[i].msgID);
+         exit(-1);
+       }
+       if (eventMessages[i].msgID >= MAX_MESSAGES) {
+         printf("ERROR: [file %s, event %d] msgID of message send (%d) is greater than the max message ID number (%d)\n", 
+                fileName, eventNum, eventMessages[i].msgID, MAX_MESSAGES);
+         exit(-1);
+       }
+       if (eventMessages[i].group < -1) {
+         printf("ERROR: [file %s, event %d] group (%d) of msgID %d must be >= -1 (and only == -1 for multicasts)\n", 
+                fileName, eventNum, eventMessages[i].group, eventMessages[i].msgID);
+         exit(-1);
+       }
+       // check that the msgID hasn't been used yet; account for
+       // multicasts, in which it's used more than once
+       if (msgIDsFree[eventMessages[i].msgID] > 0) {  // not used yet
+         if (eventMessages[i].group < 1) {  // group == -1 should only happen in successive multicast messages
+           printf("ERROR: [file %s, event %d] group (%d) of msgID %d must be >= 1 (and only > 1 for multicasts) because this doesn't look like part of a multicast\n", 
+                  fileName, eventNum, eventMessages[i].group, eventMessages[i].msgID);
+           exit(-1);
+         } else if (eventMessages[i].group == 1) {  // normal unicast or broadcast
+           msgIDsFree[eventMessages[i].msgID] = 0;
+         } else {  // multicast
+           msgIDsFree[eventMessages[i].msgID] = 1 - eventMessages[i].group;
+         }
+       } else if (msgIDsFree[eventMessages[i].msgID] == 0) {  // used too many times
+         printf("ERROR: [file %s, event %d] msgID (%d) has already been used (or used too many times for a multicast)\n", 
+                fileName, eventNum, eventMessages[i].msgID);
+         exit(-1);
+       } else {  // part of a multicast
+         if (eventMessages[i].group != -1) {
+           printf("ERROR: [file %s, event %d] group (%d) of msgID %d must be -1 because its supposedly part of a multicast\n", 
+                  fileName, eventNum, eventMessages[i].group, eventMessages[i].msgID);
+           exit(-1);
+         } else {
+           msgIDsFree[eventMessages[i].msgID]++;
+         }
+       }
+       // check message send and receive times
+       if ((eventMessages[i].sent < startTime) || (eventMessages[i].sent > endTime)) {
+         printf("ERROR: [file %s, event %d] send time (%lf) of msgID %d must be between the startTime (%lf) and endTime (%lf) of the event, inclusive\n", 
+                fileName, eventNum, eventMessages[i].sent, eventMessages[i].msgID, startTime, endTime);
+         exit(-1);
+       }
+       if (eventMessages[i].recvtime < eventMessages[i].sent) {
+         printf("ERROR: [file %s, event %d] recvtime (%lf) of msgID %d must be >= the message send time (%lf)\n", 
+                fileName, eventNum, eventMessages[i].recvtime, eventMessages[i].msgID, eventMessages[i].sent);
+         exit(-1);
+       }
+       // check the destination node
+       if ((eventMessages[i].dstNode <= -100 - numNodes) || 
+           ((eventMessages[i].dstNode < -1) && (eventMessages[i].dstNode > -100)) || 
+           (eventMessages[i].dstNode >= numNodes)) {
+         printf("ERROR: [file %s, event %d] dstNode (%d) of msgID %d must be:\n", 
+                fileName, eventNum, eventMessages[i].dstNode, eventMessages[i].msgID);
+         printf("          between -100 and %d, inclusive, for a broadcast-all-except\n", -100 - numNodes + 1);
+         printf("          -1 for a boadcast-all\n");
+         printf("          between 0 and %d, inclusive, for a normal unicast or multicast send\n", numNodes - 1);
+         exit(-1);
+       }
+       // check the destination thread ID
+       if ((eventMessages[i].tid < -1) || (eventMessages[i].tid >= numWth)) {
+         printf("ERROR: [file %s, event %d] tid (%d) of msgID %d must be:\n", 
+                fileName, eventNum, eventMessages[i].tid, eventMessages[i].msgID);
+         printf("          -1 for a broadcast to all cores in the node\n");
+         printf("          between 0 and %d, inclusive, for a normal unicast or multicast send to one core of the node\n", numWth - 1);
+         exit(-1);
+       }
+       // check the message size
+       if (eventMessages[i].size < 1) {
+         printf("ERROR: [file %s, event %d] the size (%d) of msgID %d must be at least 1 byte\n", 
+                fileName, eventNum, eventMessages[i].size, eventMessages[i].msgID);
+         exit(-1);
+       }
+      }
+      // ensure the first event in time line 0 isn't a stand-alone event
+      if ((logNum == 0) && (eventNum == 0) && (strcmp(eventName, "addMsg") == 0)) {
+       printf("ERROR: the first simulation event (event 0 of file %s) should not be a stand-alone event (i.e., named 'addMsg')\n", fileName);
+       exit(-1);
+      }
+      // ensure some of the stand-alone event criteria
+      if ((strcmp(eventName, "addMsg") == 0) && ((srcpe != -1) || (msgID != -1))) {
+       printf("ERROR: [file %s, event %d] stand-alone event (with event name 'addMsg') must have both srcpe (%d) and msgID (%d) set to -1\n", 
+              fileName, eventNum, srcpe, msgID);
+       exit(-1);
+      }
+
+      /************* Create the BgTimeLog and insert into time line *************/
+      newLog = new BgTimeLog(BgMsgID(srcpe, msgID));
+      newLog->setName(eventName);
+      newLog->setEP(ep);
+      newLog->setCharmEP((short)charm_ep);
+      newLog->setTime(startTime, endTime);
+      // set receive time for first event of each time line to 0
+      if (eventNum == 0) {
+       newLog->recvTime = 0.0;
+      }
+      // set recvTime of stand-alone events to startTime
+      if (strcmp(eventName, "addMsg") == 0) {
+       newLog->recvTime = newLog->startTime;
+      }
+
+      for (int i = 0; i < eventMessages.length(); i++) {
+       newMsg = new BgMsgEntry(eventMessages[i].msgID, eventMessages[i].size, eventMessages[i].sent, 
+                               eventMessages[i].recvtime, eventMessages[i].dstNode, eventMessages[i].tid);
+       newMsg->group = eventMessages[i].group;
+       newLog->addMsg(newMsg);
+      }
+
+      tlinerecs[logNum].logEntryInsert(newLog);
+
+      lastEndTime = endTime;
+      eventCount++;
+    }
+
+    /************* Connect all dependencies in this time line *************/
+    for (int i = 0; i < dependencies.length(); i++) {
+      if (dependencies[i].two >= eventCount) {
+       printf("ERROR: [file %s, event %d] event has a forward dependent (%d) that is out of range (must be between 0 and %d, inclusive)\n", 
+              fileName, dependencies[i].one, dependencies[i].two, eventCount - 1);
+       exit(-1);
+      }
+      tlinerecs[logNum][dependencies[i].two]->addBackwardDep(tlinerecs[logNum][dependencies[i].one]);
+    }
+
+  }
+
+  /************* Ensure all messages are received *************/
+  for (int pe = 0; pe < numPEs; pe++) {
+    for (int event = 0; event < tlinerecs[pe].length(); event++) {
+      for (int msg = 0; msg < tlinerecs[pe][event]->msgs.length(); msg++) {
+       int destNode = tlinerecs[pe][event]->msgs[msg]->dstNode;
+       int found = 0;
+
+       if (destNode <= -100) {  // broadcast except
+         int nodeException = -100 - destNode;
+         int peException = -1;
+         if (tlinerecs[pe][event]->msgs[msg]->tID >= 0) {
+           peException = (nodeException * numWth) + tlinerecs[pe][event]->msgs[msg]->tID;
+         }
+         for (int destPE = 0; destPE < numPEs; destPE++) {
+           found = 0;
+           for (int destEvent = 0; destEvent < tlinerecs[destPE].length(); destEvent++) {
+             if ((tlinerecs[destPE][destEvent]->msgId.pe() == pe) && 
+                 (tlinerecs[destPE][destEvent]->msgId.msgID() == tlinerecs[pe][event]->msgs[msg]->msgID)) {
+               found++;
+               // update event receive time based on message receive time
+               tlinerecs[destPE][destEvent]->recvTime = tlinerecs[pe][event]->msgs[msg]->recvTime;
+               // ensure the event startTime is not before the message receive time
+               if (tlinerecs[destPE][destEvent]->startTime < tlinerecs[destPE][destEvent]->recvTime) {
+                 printf("ERROR: event %d in time line %d has a startTime (%lf) that is before its recvTime (%lf)\n", 
+                        destEvent, destPE, tlinerecs[destPE][destEvent]->startTime, tlinerecs[destPE][destEvent]->recvTime);
+                 exit(-1);
+               }
+             }
+           }
+           if ((destPE == peException) || ((peException == -1) && ((destPE / numWth) == nodeException))) {
+             // this is an exempt destPE, so it shouldn't have been found here
+             if (found > 0) {
+               printf("ERROR: broadcast-except message with msgID %d sent from event %d in time line %d is received by PE %d (it should not be)\n", 
+                      msg, event, pe, destPE);
+               exit(-1);
+             }
+           } else {
+             // it should only be found once
+             if (found > 1) {
+               printf("ERROR: broadcast-except message with msgID %d sent from event %d in time line %d is received %d times by PE %d (should be 1 time)\n", 
+                      msg, event, pe, found, destPE);
+               exit(-1);
+             } else if (found < 1) {
+               printf("ERROR: broadcast-except message with msgID %d sent from event %d in time line %d is never received by PE %d\n", 
+                      msg, event, pe, destPE);
+               exit(-1);
+             }
+           }
+         }
+       } else if (destNode == -1) {  // broadcast all
+         for (int destPE = 0; destPE < numPEs; destPE++) {
+           found = 0;
+           for (int destEvent = 0; destEvent < tlinerecs[destPE].length(); destEvent++) {
+             if ((tlinerecs[destPE][destEvent]->msgId.pe() == pe) && 
+                 (tlinerecs[destPE][destEvent]->msgId.msgID() == tlinerecs[pe][event]->msgs[msg]->msgID)) {
+               found++;
+               // update event receive time based on message receive time
+               tlinerecs[destPE][destEvent]->recvTime = tlinerecs[pe][event]->msgs[msg]->recvTime;
+               // ensure the event startTime is not before the message receive time
+               if (tlinerecs[destPE][destEvent]->startTime < tlinerecs[destPE][destEvent]->recvTime) {
+                 printf("ERROR: event %d in time line %d has a startTime (%lf) that is before its recvTime (%lf)\n", 
+                        destEvent, destPE, tlinerecs[destPE][destEvent]->startTime, tlinerecs[destPE][destEvent]->recvTime);
+                 exit(-1);
+               }
+             }
+           }
+           // it should only be found once
+           if (found > 1) {
+             printf("ERROR: broadcast-all message with msgID %d sent from event %d in time line %d is received %d times by PE %d (should be 1 time)\n", 
+                    msg, event, pe, found, destPE);
+             exit(-1);
+           } else if (found < 1) {
+             printf("ERROR: broadcast-all message with msgID %d sent from event %d in time line %d is never received by PE %d\n", 
+                    msg, event, pe, destPE);
+             exit(-1);
+           }
+         }
+       } else {  // unicast
+         int destPE = (tlinerecs[pe][event]->msgs[msg]->dstNode * numWth) + tlinerecs[pe][event]->msgs[msg]->tID;
+         for (int destEvent = 0; destEvent < tlinerecs[destPE].length(); destEvent++) {
+           if ((tlinerecs[destPE][destEvent]->msgId.pe() == pe) && 
+               (tlinerecs[destPE][destEvent]->msgId.msgID() == tlinerecs[pe][event]->msgs[msg]->msgID)) {
+             found++;
+             // update event receive time based on message receive time
+             tlinerecs[destPE][destEvent]->recvTime = tlinerecs[pe][event]->msgs[msg]->recvTime;
+             // ensure the event startTime is not before the message receive time
+             if (tlinerecs[destPE][destEvent]->startTime < tlinerecs[destPE][destEvent]->recvTime) {
+               printf("ERROR: event %d in time line %d has a startTime (%lf) that is before its recvTime (%lf)\n", 
+                      destEvent, destPE, tlinerecs[destPE][destEvent]->startTime, tlinerecs[destPE][destEvent]->recvTime);
+               exit(-1);
+             }
+           }
+         }
+         // it should only be found once
+         if (found > 1) {
+           printf("ERROR: unicast message with msgID %d sent from event %d in time line %d is received %d times by PE %d (should be 1 time)\n", 
+                  msg, event, pe, found, destPE);
+           exit(-1);
+         } else if (found < 1) {
+           printf("ERROR: unicast message with msgID %d sent from event %d in time line %d is never received by PE %d\n", 
+                  msg, event, pe, destPE);
+           exit(-1);
+         }
+       }
+      }
+    }
+  }
+
+  /************* Ensure all message receives have a sender and no backward dependents *************/
+  for (int pe = 0; pe < numPEs; pe++) {
+    for (int event = 0; event < tlinerecs[pe].length(); event++) {
+      if (tlinerecs[pe][event]->msgId.pe() >= 0) {
+       // ensure no backward dependents
+       if (tlinerecs[pe][event]->backwardDeps.length() > 0) {
+         printf("ERROR: event %d in time line %d has %d backward dependent(s); it should have 0 because it looks like a message receive event\n", 
+                event, pe, tlinerecs[pe][event]->backwardDeps.length());
+         exit(-1);
+       }
+       // ensure it has a sender
+       srcpe = tlinerecs[pe][event]->msgId.pe();
+       msgID = tlinerecs[pe][event]->msgId.msgID();
+       bool found = false;
+       for (int srcEvent = 0; srcEvent < tlinerecs[srcpe].length(); srcEvent++) {
+         for (int msg = 0; msg < tlinerecs[srcpe][srcEvent]->msgs.length(); msg++) {
+           if (tlinerecs[srcpe][srcEvent]->msgs[msg]->msgID == msgID) {
+             found = true;
+             break;
+           }
+         }
+         if (found) break;
+       }
+       if (!found) {
+         printf("ERROR: event %d in time line %d does not have a corresponding message sent from time line %d\n", event, pe, srcpe);
+         exit(-1);
+       }
+      }
+    }
+  }
+
+  /************* Write time lines to bgTrace files *************/
+  // write trace summary file
+  BgWriteTraceSummary(numTraces, numXNodes, numYNodes, numZNodes, numWth, 1, NULL, NULL);
+
+  // Write trace files in round-robin fashion by node.
+  // NOTE: The worker threads (i.e., cores) on each node must be kept
+  // together.  For example:
+  //
+  //    8 target PEs, 2 emulating procs (2 trace files), numWth = 1
+  //       tlinerecs = [0 1 2 3 4 5 6 7]
+  //       bgTrace0 (tlinetemp[0]) = [0 2 4 6]
+  //       bgTrace1 (tlinetemp[1]) = [1 3 5 7]
+  //
+  //    Same as above but with numWth = 2 -> the time lines must be
+  //    grouped in 2s (01, 23, 45, 67)
+  //       tlinerecs = [0 1 2 3 4 5 6 7]
+  //       bgTrace0 (tlinetemp[0]) = [01 45] = [0 1 4 5]
+  //       bgTrace1 (tlinetemp[1]) = [23 67] = [2 3 6 7]
+  for (int trace = 0; trace < numTraces; trace++) {
+    int numProcs;
+    if (trace < (numPEs % numTraces)) {
+      numProcs = (numPEs / numTraces) + 1;
+    } else {
+      numProcs = numPEs / numTraces;
+    }
+    BgTimeLineRec **tlinetemp = new BgTimeLineRec*[numProcs];
+    for (int node = 0; node < (numProcs / numWth); node++) {
+      for (int proc = 0; proc < numWth; proc++) {
+       tlinetemp[(node*numWth)+proc] = &tlinerecs[(numTraces*node+trace)*numWth+proc];
+      }
+    }
+    BgWriteTimelines(trace, tlinetemp, numProcs);
+    delete [] tlinetemp;
+  }
+}
index 5b9eb8e0fa5833790907a47acb903489cbf766d5..1a43ea04b029b48cc4e674ab5d49c3dba0a2e2ef 100644 (file)
@@ -1,6 +1,5 @@
-DIRS=hello integrate integrate2 integrateArray \
-       piArray queens RedExample \
-       ring rings speeds
+DIRS   = hello integrate integrate2 integrateArray piArray queens RedExample \
+         ring rings speeds load_balancing
 
 all: 
        for d in $(DIRS); do \
index c5b13c8a0e2a5fd1692b5d8bf0e0dc3077a65d15..5ba5818b483b0da9592a913715bf3e9b01ce01e3 100644 (file)
@@ -8,42 +8,41 @@
 
 // convenience typedefs and consts to facilitate float vs double usage
 #define USE_DOUBLE 0
+
 #if USE_DOUBLE
-typedef double  MD_FLOAT;
-#define  MD_VEC veclf
-const double zero=0.0;
-const double one=1.0;
-const double two=2.0;
-#define myvec_numElems veclf_numElems;
-#define vextract_MDF vextractlf
-#define vsub_MDF vsublf
-#define vadd_MDF vaddlf
-#define vmadd_MDF vmaddlf
-#define vmul_MDF vmullf
-#define vspread_MDF vspreadlf
-#define vrecip_MDF vreciplf
-#define vsqrt_MDF vsqrtlf
-#define visfinite_MDF visfinitelf
+  typedef double  MD_FLOAT;
+  #define  MD_VEC simdia_veclf
+  const double zero=0.0;
+  const double one=1.0;
+  const double two=2.0;
+  #define myvec_numElems simdia_veclf_numElems;
+  #define vextract_MDF simdia_vextractlf
+  #define vsub_MDF simdia_vsublf
+  #define vadd_MDF simdia_vaddlf
+  #define vmadd_MDF simdia_vmaddlf
+  #define vmul_MDF simdia_vmullf
+  #define vspread_MDF simdia_vspreadlf
+  #define vrecip_MDF simdia_vreciplf
+  #define vsqrt_MDF simdia_vsqrtlf
+  #define visfinite_MDF simdia_visfinitelf
 #else
-typedef float  MD_FLOAT;
-#define  MD_VEC vecf
-#define myvec_numElems vecf_numElems;
-const float zero=0.0f;
-const float one=1.0f;
-const float two=2.0f;
-
-#define vextract_MDF vextractf
-#define vsub_MDF vsubf
-#define vadd_MDF vaddf
-#define vmadd_MDF vmaddf
-#define vmul_MDF vmulf
-#define vspread_MDF vspreadf
-#define vrecip_MDF vrecipf
-#define vsqrt_MDF vsqrtf
-#define visfinite_MDF visfinitef
+  typedef float  MD_FLOAT;
+  #define  MD_VEC simdia_vecf
+  #define myvec_numElems simdia_vecf_numElems;
+  const float zero=0.0f;
+  const float one=1.0f;
+  const float two=2.0f;
+  #define vextract_MDF simdia_vextractf
+  #define vsub_MDF simdia_vsubf
+  #define vadd_MDF simdia_vaddf
+  #define vmadd_MDF simdia_vmaddf
+  #define vmul_MDF simdia_vmulf
+  #define vspread_MDF simdia_vspreadf
+  #define vrecip_MDF simdia_vrecipf
+  #define vsqrt_MDF simdia_vsqrtf
+  #define visfinite_MDF simdia_visfinitef
 #endif
 
-
 #define DEFAULT_NUM_PARTICLES_PER_PATCH  (128)
 
 #define DEFAULT_NUM_PATCHES_X              (2)
diff --git a/examples/charm++/imbalanced/LB_Bench.C b/examples/charm++/imbalanced/LB_Bench.C
deleted file mode 100644 (file)
index aa0c4c0..0000000
+++ /dev/null
@@ -1,210 +0,0 @@
-#include "LB_Bench.decl.h"
-#include "charm++.h"
-
-// See README for documentation
-
-/*readonly*/ CProxy_Main mainProxy;
-/*readonly*/ int num_chare_rows;
-/*readonly*/ int num_chare_cols;
-
-// We want to wrap entries around, and because mod operator % sometimes misbehaves on negative values, 
-// I just wrote these simple wrappers that will make the mod work as expected. -1 maps to the highest value.
-#define wrap_x(a)  (((a)+num_chare_cols)%num_chare_cols)
-#define wrap_y(a)  (((a)+num_chare_rows)%num_chare_rows)
-
-CkArrayID a;
-
-#define total_iterations 200
-
-class Main : public CBase_Main
-{
-public:
-  int done_count;
-  CProxy_LB_Bench array;
-  int num_chares;
-
-  Main(CkArgMsg* m) {
-       if (m->argc < 2) {
-         CkPrintf("%s [number chares per dimension]\n", m->argv[0]);
-         CkAbort("Abort");
-       }
-
-       // store the main proxy
-       mainProxy = thisProxy;
-
-       num_chare_rows = atoi(m->argv[1]);
-       num_chare_cols = atoi(m->argv[1]);
-
-       // print info
-       CkPrintf("Running on %d processors with a %d x %d chare array\n", CkNumPes(), num_chare_rows, num_chare_cols);
-
-       // Create new array of worker chares
-       array = CProxy_LB_Bench::ckNew(num_chare_cols, num_chare_rows);
-
-       // save the total number of worker chares we have in this simulation
-       num_chares = num_chare_rows*num_chare_cols;
-
-       //Start the computation
-       done_count = 0;
-       array.startup();
-  }
-
-  // Each worker reports back to here when it completes an iteration
-  void report_done() {
-       done_count++;
-       if (num_chares == done_count) {
-         CkPrintf("Done\n");
-         CkExit();
-       }
-  }
-
-};
-
-class LB_Bench: public CBase_LB_Bench {
-public:
-  int iterations;
-  int received_right, received_left, received_up, received_down;
-
-  // Constructor
-  LB_Bench() : iterations(0), received_right(0), received_down(0), received_up(0), received_left(0) {
-       /*      iterations=0;
-         received_right=0;
-         received_left=0;
-         received_up=0;
-         received_down=0;
-       */
-  }
-
-  // For migration
-  LB_Bench(CkMigrateMessage* m) {}
-
-  // Destructor
-  ~LB_Bench() { }
-
-  // Perform one iteration of work
-  // The first step is to send the local state to the neighbors
-  void startup(void) {
-       next_iter();
-  }
-
-  void next_iter(){
-       thisProxy(wrap_x(thisIndex.x-1), thisIndex.y).fromRight();
-       thisProxy(wrap_x(thisIndex.x+1), thisIndex.y).fromLeft();
-       thisProxy(thisIndex.x, wrap_y(thisIndex.y-1)).fromDown();
-       thisProxy(thisIndex.x, wrap_y(thisIndex.y+1)).fromUp();
-
-       if(iterations % 10 ==5 &&  usesAtSync==CmiTrue )
-         AtSync();
-
-
-  }
-
-  void fromRight() {
-       received_right ++;
-       //      CkPrintf("%d,%d R=%d L=%d D=%d U=%d\n", thisIndex.x, thisIndex.y, received_right, received_left, received_down, received_up);
-       //      CkAssert(received_right <= 2);
-       check_and_compute();
-  }
-
-  void fromLeft() {
-       received_left ++;
-       //      CkPrintf("%d,%d R=%d L=%d D=%d U=%d\n", thisIndex.x, thisIndex.y, received_right, received_left, received_down, received_up);
-       //      CkAssert(received_left <= 2);
-       check_and_compute();
-  }
-
-  void fromDown() {
-       received_down ++;
-       //      CkPrintf("%d,%d R=%d L=%d D=%d U=%d\n", thisIndex.x, thisIndex.y, received_right, received_left, received_down, received_up);
-       //CkAssert(received_down <= 2);
-       check_and_compute();
-  }
-
-  void fromUp() {
-       received_up ++;
-       //      CkPrintf("%d,%d R=%d L=%d D=%d U=%d\n", thisIndex.x, thisIndex.y, received_right, received_left, received_down, received_up);
-       //      CkAssert(received_up <= 2);
-       check_and_compute();
-  }
-
-  void check_and_compute() {
-       if(received_right>0 && received_left>0 && received_up>0 && received_down>0) {
-         //CkPrintf("%d,%d ====================== \n", thisIndex.x, thisIndex.y);
-
-         received_right --;
-         received_left --;
-         received_down --;
-         received_up --;
-         
-         //      CkPrintf("%d,%d R=%d L=%d D=%d U=%d\n", thisIndex.x, thisIndex.y, received_right, received_left, received_down, received_up);
-
-         if(iterations < total_iterations){
-               iterations++;
-               thisProxy(thisIndex.x,thisIndex.y).compute();
-         } else {
-               mainProxy.report_done();
-         }
-
-       }
-  }
-
-
-  void compute() {
-       double work_factor = 1.0;
-
-       //      CkPrintf("my x index is %d of %d, iteration=%d\n", thisIndex.x, num_chare_cols, iterations);
-       if(thisIndex.x >= num_chare_cols*0.40 && thisIndex.x <= num_chare_cols*0.60){
-         const double start_activate=0.4*(double)total_iterations;
-         const double end_activate=0.7*(double)total_iterations;
-         double fraction_activated;
-
-         if(iterations < start_activate)
-               fraction_activated = 0.0;
-         else if(iterations > end_activate)
-               fraction_activated = 1.0;
-         else
-               fraction_activated = ((double)iterations-start_activate) / (end_activate-start_activate); 
-
-         if( ((double)thisIndex.y / ((double)num_chare_rows-1.0)) <= fraction_activated)
-               work_factor += num_chare_rows*2.0;
-         //      CkPrintf("x index %d has work_factor %f at iteration %d\n", thisIndex.x, work_factor, iterations);
-       }
-
-       double a[2000], b[2000], c[2000];
-       for(int j=0;j<100*work_factor;j++){
-         for(int i=0;i<2000;i++){
-               a[i] = 7.0;
-               b[i] = 5.0;
-         }
-         for(int i=0;i<2000/2;i++){
-               c[i] = a[2*i]*b[2*i+1]*a[i];
-               c[2*i] = a[2*i];
-         }
-       }
-
-       next_iter();
-  }
-
-
-  void ResumeFromSync(void) { //Called by Load-balancing framework
-       // CkPrintf("Element %d,%d resumeFromSync on PE %d\n",thisIndex.x, thisIndex.y, CkMyPe());
-  }
-
-
-  virtual void pup(PUP::er &p)
-  {
-    CBase_LB_Bench::pup(p);
-    p | iterations;
-    p | received_right;
-    p | received_left;
-    p | received_up;
-    p | received_down;
-  }
-
-
-
-
-};
-
-#include "LB_Bench.def.h"
diff --git a/examples/charm++/imbalanced/LB_Bench.ci b/examples/charm++/imbalanced/LB_Bench.ci
deleted file mode 100644 (file)
index bc946d8..0000000
+++ /dev/null
@@ -1,22 +0,0 @@
-mainmodule LB_Bench {
-  readonly CProxy_Main mainProxy;
-  readonly int num_chare_rows;
-  readonly int num_chare_cols;
-
-  mainchare Main {
-    entry Main(CkArgMsg *m);
-    entry void report_done();
-  };
-
-  array [2D] LB_Bench {
-    // Normal Charm++ entry methods
-    entry LB_Bench(void);
-    entry void compute();
-    entry void fromLeft();
-    entry void fromRight();
-    entry void fromUp();
-    entry void fromDown();
-    entry void startup();
-    entry void next_iter();
-  };
-};
diff --git a/examples/charm++/imbalanced/Makefile b/examples/charm++/imbalanced/Makefile
deleted file mode 100644 (file)
index 0466ea8..0000000
+++ /dev/null
@@ -1,28 +0,0 @@
-CHARMC=../../../bin/charmc $(OPTS)
-
-OBJS = LB_Bench.o
-PROJ= -tracemode projections -tracemode summary
-
-all: LB_Bench LB_Bench_Proj LB_Bench_Proj_LB
-
-LB_Bench: $(OBJS)
-       $(CHARMC) -language charm++ -o LB_Bench $(OBJS)
-
-LB_Bench_Proj: $(OBJS)
-       $(CHARMC) -language charm++ -o LB_Bench_Proj $(PROJ) $(OBJS)
-
-LB_Bench_Proj_LB: $(OBJS)
-       $(CHARMC) -language charm++ -o LB_Bench_Proj_LB -module CommonLBs $(PROJ) $(OBJS)
-
-LB_Bench.decl.h: LB_Bench.ci
-       $(CHARMC)  LB_Bench.ci
-
-test: LB_Bench_Proj_LB
-       rm logs/* 
-       srun  --sockets-per-node=2 LB_Bench_Proj_LB 16 +traceroot logs/ +LBPeriod 2
-
-clean:
-       rm -f *.decl.h *.def.h conv-host *.o LB_Bench charmrun *~ *.core LB_Bench_Proj *.projrc *.sts logs/*
-
-LB_Bench.o: LB_Bench.C LB_Bench.decl.h
-       $(CHARMC) -c LB_Bench.C
diff --git a/examples/charm++/imbalanced/README b/examples/charm++/imbalanced/README
deleted file mode 100644 (file)
index c2cc7bd..0000000
+++ /dev/null
@@ -1,37 +0,0 @@
-Author: Isaac Dooley
-
-A simple benchmarking example for use with load balancing schemes. The program uses a 2-d array of chares, each communicating with its 4 neighbors. The program mimics the load pattern of the code named Fractography3-d.
-
-
-Beginning: 
-
-CCCCCCCCCCCC        Legend: C fixed constant amount of work
-CCCCCCCCCCCC                L large amount of work
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-
-Middle:
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-LLLLLLCCCCCC
-LLLLLLCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-
-
-End
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-LLLLLLLLLLLL
-LLLLLLLLLLLL
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-CCCCCCCCCCCC
-
index 2f2666463e6a5dc6f388aa92c51d4c77719d746f..fe54575eb74ba0a2fdd84774076839129191c5b6 100644 (file)
@@ -250,6 +250,13 @@ class Jacobi: public CBase_Jacobi {
       // Send my back face
       thisProxy(thisIndex.x, thisIndex.y, wrap_z(thisIndex.z+1))
          .receiveGhosts(iterations, FRONT, blockDimX, blockDimY, backGhost);
+
+      delete[] leftGhost;
+      delete[] rightGhost;
+      delete[] bottomGhost;
+      delete[] topGhost;
+      delete[] frontGhost;
+      delete[] backGhost;
     }
 
     void processGhosts(int dir, int height, int width, double gh[]) {
diff --git a/examples/charm++/load_balancing/Makefile b/examples/charm++/load_balancing/Makefile
new file mode 100644 (file)
index 0000000..5d2f23e
--- /dev/null
@@ -0,0 +1,21 @@
+DIRS   = stencil3d kNeighbor
+
+all:
+       for d in $(DIRS); do \
+               (cd $$d; $(MAKE) all OPTS='$(OPTS)' || exit 1) || exit 1; \
+       done
+
+test:
+       for d in $(DIRS); do \
+               (cd $$d; $(MAKE) test OPTS='$(OPTS)' TESTOPTS='$(TESTOPTS)' || exit 1) || exit 1; \
+       done
+
+bgtest:
+       for d in $(DIRS); do \
+               (cd $$d; $(MAKE) bgtest OPTS='$(OPTS)' || exit 1) || exit 1; \
+       done
+
+clean:
+       for d in $(DIRS); do (cd $$d; $(MAKE) clean OPTS='$(OPTS)'); done
+       rm -f TAGS #*#
+       rm -f core *~
diff --git a/examples/charm++/load_balancing/kNeighbor/Makefile b/examples/charm++/load_balancing/kNeighbor/Makefile
new file mode 100644 (file)
index 0000000..9ba8e46
--- /dev/null
@@ -0,0 +1,28 @@
+OPTS   = -O3
+CHARMC = ../../../../bin/charmc $(OPTS)
+
+OBJS   = kNeighbor.o
+
+all: kNeighbor 
+
+kNeighbor: $(OBJS)
+       $(CHARMC) -language charm++ -module CommonLBs -o kNeighbor $(OBJS)
+
+projections: $(COMPOBJS)
+       $(CHARMC) -language charm++ -tracemode projections -lz -o kNeighbor.prj $(OBJS)
+
+kNeighbor.decl.h: kNeighbor.ci
+       $(CHARMC) kNeighbor.ci
+
+kNeighbor.o: kNeighbor.C kNeighbor.decl.h
+       $(CHARMC) -c kNeighbor.C
+
+clean:
+       rm -f *.decl.h *.def.h conv-host *.o charmrun *~ kNeighbor kNeighbor.prj
+
+test: all
+       ./charmrun +p4 ./kNeighbor 15 100 1024 10 +balancer GreedyLB $(TESTOPTS)
+
+bgtest: all
+       ./charmrun +p4 ./kNeighbor 20 100 1024 10 +balancer GreedyLB +x2 +y2 +z1 +cth1 +wth1
+
diff --git a/examples/charm++/load_balancing/kNeighbor/kNeighbor.C b/examples/charm++/load_balancing/kNeighbor/kNeighbor.C
new file mode 100644 (file)
index 0000000..2de665f
--- /dev/null
@@ -0,0 +1,494 @@
+/** \file kNeighbor.C
+ *  Author: Chao Mei
+ *
+ */
+
+#include "kNeighbor.decl.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+#define STRIDEK                1
+#define CALCPERSTEP    100
+#define WRAPAROUND     1
+#define ALLCROSSNODE   0
+
+#define DEBUG          0
+#define REUSE_ITER_MSG 0
+#define TOUCH_MSGDATA  0
+
+#define WORKSIZECNT    1
+#define MSGSIZECNT     1
+
+/* readonly */ CProxy_Main mainProxy;
+/* readonly */ int num_chares;
+/* readonly */ int gMsgSize;
+/* readonly */ int gLBFreq;
+
+int cmpFunc(const void *a, const void *b) {
+  if(*(double *)a < *(double *)b) return -1;
+  if(*(double *)a > *(double *)b) return 1;
+  return 0;
+}
+
+class toNeighborMsg: public CMessage_toNeighborMsg {
+  public:
+    int *data;
+    int size;
+    int fromX;
+    int nID;
+
+  public:
+    toNeighborMsg() {};
+    toNeighborMsg(int s): size(s) {  
+#if TOUCH_MSGDATA
+      init();
+#endif
+    }
+
+    void setMsgSrc(int X, int id) {
+      fromX = X;
+      nID = id;
+    }
+
+    void init() {
+      for (int i=0; i<size; i++)
+        data[i] = i;
+    }
+
+    int sum() {
+      int s=0;
+      for (int i=0; i<size; i++)
+        s += data[i];
+      return s;
+    }
+};
+
+class Main: public CBase_Main {
+  public:
+    CProxy_Block array;
+
+    //static int msgSizeArr[MSGSIZECNT];
+
+    int numSteps;
+    int currentStep;
+    int currentMsgSize;
+
+    int elementsRecved;
+    double totalTime;
+    double maxTime;
+    double minTime;
+    double *timeRec;
+
+    double gStarttime;
+
+  public:
+    Main(CkArgMsg *m) {
+      mainProxy = thisProxy;
+      CkPrintf("\nStarting kNeighbor ...\n");
+
+      if (m->argc!=4 && m->argc!=5) {
+        CkPrintf("Usage: %s <#elements> <#iterations> <msg size> [ldb freq]\n", m->argv[0]);
+        delete m;
+        CkExit();
+      }
+
+      num_chares = atoi(m->argv[1]);
+      if(num_chares < CkNumPes()) {
+       printf("Warning: #elements is forced to be equal to #pes\n");
+       num_chares = CkNumPes();
+      }
+
+      numSteps = atoi(m->argv[2]);
+      currentMsgSize = atoi(m->argv[3]);
+
+      gLBFreq = 100000;        
+      if(m->argc==5) {
+       gLBFreq = atoi(m->argv[4]);
+      }
+
+#if TURN_ON_LDB
+      printf("Setting load-balancing freq to every %d steps\n", gLBFreq);  
+#endif
+#if REUSE_ITER_MSG
+      gMsgSize = currentMsgSize;
+#endif
+
+      currentStep = -1;
+      timeRec = new double[numSteps];
+
+      array = CProxy_Block::ckNew(num_chares);
+      CkCallback *cb = new CkCallback(CkIndex_Main::nextStep(NULL), thisProxy);
+      array.ckSetReductionClient(cb);
+
+      beginIteration();
+    }
+
+    void beginIteration() {
+      currentStep++;
+      if (currentStep == numSteps) {
+       CkPrintf("kNeighbor program finished!\n");
+       //CkCallback *cb = new CkCallback(CkIndex_Main::terminate(NULL), thisProxy);
+       //array.ckSetReductionClient(cb);
+       //array.printSts(numSteps);
+       terminate(NULL);
+       return;
+       //CkExit();
+      }
+
+      elementsRecved = 0;
+      totalTime = 0.0;
+      maxTime = 0.0;
+      minTime = 3600.0;
+
+      //int msgSize = msgSizeArr[currentStep%MSGSIZECNT];
+      //int msgSize = msgSizeArr[rand()%MSGSIZECNT];
+      //currentMsgSize = msgSize;
+      if(currentStep!=0 && (currentStep % gLBFreq == 0)) {
+       array.pauseForLB();
+       return;
+      }
+
+      gStarttime = CmiWallTimer();
+#if REUSE_ITER_MSG
+      for (int i=0; i<num_chares; i++)
+       array[i].commWithNeighbors();
+#else
+      for (int i=0; i<num_chares; i++)
+       array[i].commWithNeighbors(currentMsgSize);
+#endif 
+      //array.commWithNeighbors(currentMsgSize);
+    }
+    
+    void resumeIter() {
+#if DEBUG
+      CkPrintf("Resume iteration at step %d\n", currentStep);
+#endif
+      gStarttime = CmiWallTimer();
+#if REUSE_ITER_MSG
+      for (int i=0; i<num_chares; i++)
+       array[i].commWithNeighbors();
+#else
+      for (int i=0; i<num_chares; i++)
+       array[i].commWithNeighbors(currentMsgSize);
+#endif
+    }
+
+    void terminate(CkReductionMsg *msg) {
+      delete msg;
+      double total = 0.0;
+
+      for (int i=0; i<numSteps; i++)
+       timeRec[i] = timeRec[i]*1e6;
+
+      qsort(timeRec, numSteps, sizeof(double), cmpFunc);
+      printf("Time stats: lowest: %f, median: %f, highest: %f\n", timeRec[0], timeRec[numSteps/2], timeRec[numSteps-1]);
+
+      int samples = 100;
+      if(numSteps<=samples) samples = numSteps-1;
+      for (int i=0; i<samples; i++)
+       total += timeRec[i];
+      total /= samples;
+
+      CkPrintf("Average time for each %d-Neighbor iteration with msg size %d is %f (us)\n", STRIDEK, currentMsgSize, total);
+      CkExit();
+    }
+
+    void nextStep_plain(double iterTime) {
+      elementsRecved++;
+      totalTime += iterTime;
+      maxTime = maxTime>iterTime?maxTime:iterTime;
+      minTime = minTime<iterTime?minTime:iterTime;
+
+      if (elementsRecved == num_chares) {
+         double wholeStepTime = CmiWallTimer() - gStarttime;
+         timeRec[currentStep] = wholeStepTime/CALCPERSTEP;
+         //CkPrintf("Step %d with msg size %d finished: max=%f, total=%f\n", currentStep, currentMsgSize, maxTime/CALCPERSTEP, wholeStepTime/CALCPERSTEP);
+
+         beginIteration();
+      }
+    }
+
+    void nextStep(CkReductionMsg  *msg) {
+      maxTime = *((double *)msg->getData());
+      delete msg;
+      double wholeStepTime = CmiWallTimer() - gStarttime;
+      timeRec[currentStep] = wholeStepTime/CALCPERSTEP;
+      //CkPrintf("Step %d with msg size %d finished: max=%f, total=%f\n", currentStep, currentMsgSize, maxTime/CALCPERSTEP, wholeStepTime/CALCPERSTEP);
+      beginIteration();
+    }
+
+};
+
+//int Main::msgSizeArr[MSGSIZECNT] = {16, 32, 128, 256, 512, 1024, 2048, 4096};
+//int Main::msgSizeArr[MSGSIZECNT] = {10000};
+
+//no wrap around for sending messages to neighbors
+class Block: public CBase_Block {
+  public:
+    /** actual work size is of workSize^3 */
+    static int workSizeArr[WORKSIZECNT];
+
+    int numNeighbors;
+    int neighborsRecved;
+    int *neighbors;
+    double *recvTimes;
+    double startTime;
+
+    int random;
+    int curIterMsgSize;
+    int curIterWorkSize;
+    int internalStepCnt;
+    int sum;
+
+#if REUSE_ITER_MSG
+    toNeighborMsg **iterMsg;
+#endif
+
+  public:
+    Block() {
+      //srand(thisIndex.x+thisIndex.y);
+      usesAtSync = CmiTrue;
+
+#if WRAPAROUND
+      numNeighbors = 2*STRIDEK;
+      neighbors = new int[numNeighbors];
+      recvTimes = new double[numNeighbors];
+      int nidx=0;
+      //setting left neighbors
+      for (int i=thisIndex-STRIDEK; i<thisIndex; i++, nidx++) {
+       int tmpnei = i;
+       while (tmpnei<0) tmpnei += num_chares;
+       neighbors[nidx] = tmpnei;
+      }
+      //setting right neighbors
+      for (int i=thisIndex+1; i<=thisIndex+STRIDEK; i++, nidx++) {
+       int tmpnei = i;
+       while (tmpnei>=num_chares) tmpnei -= num_chares;
+       neighbors[nidx] = tmpnei;
+      }
+#elif ALLCROSSNODE
+      if(CkNumNodes()==1){
+       if(thisIndex==0){
+         CkPrintf("This version has to run with more than 2 nodes!\n");
+         CkExit();
+       }
+       return;
+      }
+      numNeighbors = CkNumNodes()-1;
+      neighbors = new int[numNeighbors];
+      recvTimes = new double[numNeighbors];
+      for(int i=0; i<numNeighbors; i++){
+       neighbors[i] = (thisIndex+(i+1)*CmiMyNodeSize())%CkNumPes();
+      }
+#else
+      //calculate the neighbors this element has
+      numNeighbors = 0;
+      numNeighbors += thisIndex - MAX(0, thisIndex-STRIDEK); //left
+      numNeighbors += MIN(num_chares-1, thisIndex+STRIDEK)-thisIndex; //right
+      neighbors = new int[numNeighbors];
+      recvTimes = new double[numNeighbors];
+      int nidx=0;
+      for (int i=MAX(0, thisIndex-STRIDEK); i<thisIndex; i++, nidx++) neighbors[nidx]=i;
+      for (int i=thisIndex+1; i<=MIN(num_chares-1, thisIndex+STRIDEK); i++, nidx++) neighbors[nidx] = i;
+#endif
+
+      for (int i=0; i<numNeighbors; i++)
+       recvTimes[i] = 0.0;
+
+#if REUSE_ITER_MSG
+      iterMsg = new toNeighborMsg *[numNeighbors];
+      for (int i=0; i<numNeighbors; i++)
+       iterMsg[i] = NULL;      
+#endif
+
+#if DEBUG
+      CkPrintf("Neighbors of %d: ", thisIndex);
+      for (int i=0; i<numNeighbors; i++)
+       CkPrintf("%d ", neighbors[i]);
+      CkPrintf("\n");
+#endif
+
+      random = thisIndex*31+73;
+    }
+
+    ~Block() {
+      delete [] neighbors;
+      delete [] recvTimes;
+#if REUSE_ITER_MSG
+      delete [] iterMsg;
+#endif
+    }
+    
+    void pup(PUP::er &p){
+      ArrayElement1D::pup(p); //pack our superclass
+      p(workSizeArr, WORKSIZECNT);
+      p(numNeighbors);
+      p(neighborsRecved);
+
+      if(p.isUnpacking()) {
+       neighbors = new int[numNeighbors];
+       recvTimes = new double[numNeighbors];
+      }
+      PUParray(p, neighbors, numNeighbors);
+      PUParray(p, recvTimes, numNeighbors);
+      p(startTime);
+      p(random);
+      p(curIterMsgSize);
+      p(curIterWorkSize);
+      p(internalStepCnt);
+      p(sum);
+#if REUSE_ITER_MSG
+      if(p.isUnpacking()) iterMsg = new toNeighborMsg *[numNeighbors];
+      for(int i=0; i<numNeighbors; i++){
+       if(p.isUnpacking()) iterMsg[i] = new(curIterMsgSize/4, 0) toNeighborMsg(curIterMsgSize/4);
+       CkPupMessage(p, (void **)&iterMsg[i]);
+      }
+#endif                 
+    }
+
+    Block(CkMigrateMessage *m) {}
+
+    void pauseForLB(){
+#if DEBUG
+      CkPrintf("Element %d pause for LB on PE %d\n", thisIndex, CkMyPe());
+#endif
+      AtSync();
+    }
+
+    void ResumeFromSync(){ //Called by load-balancing framework
+      CkCallback cb(CkIndex_Main::resumeIter(), mainProxy);
+      contribute(0, NULL, CkReduction::sum_int, cb);
+    }
+
+    void printSts(int totalSteps){
+      /*for(int i=0; i<numNeighbors; i++){
+       CkPrintf("Elem[%d]: avg RTT from neighbor %d (actual elem id %d): %lf\n", thisIndex, i, neighbors[i], recvTimes[i]/totalSteps);
+       }*/
+      contribute(0,0,CkReduction::max_int);
+    }
+
+    void startInternalIteration() {
+#if DEBUG
+      CkPrintf("[%d]: Start internal iteration \n", thisIndex);
+#endif
+
+      neighborsRecved = 0;
+      /* 1: pick a work size and do some computation */
+      int sum=0;
+      int N=curIterWorkSize;
+      for (int i=0; i<N; i++)
+       for (int j=0; j<N; j++)
+         for (int k=0; k<N; k++)
+           sum += (thisIndex*i+thisIndex*j+k)%WORKSIZECNT;
+      /* 2. send msg to K neighbors */
+      int msgSize = curIterMsgSize;
+
+      // Send msgs to neighbors
+      for (int i=0; i<numNeighbors; i++) {
+       //double memtimer = CmiWallTimer();
+
+#if REUSE_ITER_MSG
+       toNeighborMsg *msg = iterMsg[i];
+#else
+       toNeighborMsg *msg = new(msgSize/4, 0) toNeighborMsg(msgSize/4);
+#endif
+
+#if DEBUG
+       CkPrintf("[%d]: send msg to neighbor[%d]=%d\n", thisIndex, i, neighbors[i]);
+#endif
+       msg->setMsgSrc(thisIndex, i);
+       //double entrytimer = CmiWallTimer();
+       thisProxy(neighbors[i]).recvMsgs(msg);
+       //double entrylasttimer = CmiWallTimer();
+       //if(thisIndex==0){
+       //      CkPrintf("At current step %d to neighbor %d, msg creation time: %f, entrymethod fire time: %f\n", internalStepCnt, neighbors[i], entrytimer-memtimer, entrylasttimer-entrytimer);
+       //}
+      }
+    }
+
+    void commWithNeighbors(int msgSize) {
+      internalStepCnt = 0;
+      curIterMsgSize = msgSize;
+      //currently the work size is only changed every big steps (which
+      //are initiated by the main proxy
+      curIterWorkSize = workSizeArr[random%WORKSIZECNT];
+      random++;
+
+      startTime = CmiWallTimer();
+      startInternalIteration();
+    }
+
+    void commWithNeighbors() {
+      internalStepCnt = 0;
+      curIterMsgSize = gMsgSize;
+      //currently the work size is only changed every big steps (which
+      //are initiated by the main proxy
+      curIterWorkSize = workSizeArr[random%WORKSIZECNT];
+      random++;
+
+#if REUSE_ITER_MSG
+      if(iterMsg[0]==NULL) { //indicating the messages have not been created
+       for(int i=0; i<numNeighbors; i++)
+         iterMsg[i] = new(curIterMsgSize/4, 0) toNeighborMsg(curIterMsgSize/4);
+      }
+#endif
+
+      startTime = CmiWallTimer();
+      startInternalIteration();
+    }
+
+    void recvReplies(toNeighborMsg *m) {
+      int fromNID = m->nID;
+
+#if DEBUG
+      CkPrintf("[%d]: receive ack from neighbor[%d]=%d\n", thisIndex, fromNID, neighbors[fromNID]);
+#endif
+
+#if REUSE_ITER_MSG
+      iterMsg[fromNID] = m;
+#else
+      delete m;
+#endif
+      //recvTimes[fromNID] += (CmiWallTimer() - startTime);
+
+      //get one step time and send it back to mainProxy
+      neighborsRecved++;
+      if (neighborsRecved == numNeighbors) {
+       internalStepCnt++;
+       if (internalStepCnt==CALCPERSTEP) {
+         double iterCommTime = CmiWallTimer() - startTime;
+         contribute(sizeof(double), &iterCommTime, CkReduction::max_double);
+         /*if(thisIndex==0){
+           for(int i=0; i<numNeighbors; i++){
+           CkPrintf("RTT time from neighbor %d (actual elem id %d): %lf\n", i, neighbors[i], recvTimes[i]);
+           }
+           }*/
+       } else {
+         startInternalIteration();
+       }
+      }
+    }
+
+    void recvMsgs(toNeighborMsg *m) {
+#if DEBUG
+      CkPrintf("[%d]: recv msg from %d as its %dth neighbor\n", thisIndex, m->fromX, m->nID);
+#endif
+
+#if TOUCH_MSGDATA
+      sum = m->sum();
+#endif
+      thisProxy(m->fromX).recvReplies(m);
+    }
+
+    inline int MAX(int a, int b) {
+      return (a>b)?a:b;
+    }
+    inline int MIN(int a, int b) {
+      return (a<b)?a:b;
+    }
+};
+
+//int Block::workSizeArr[WORKSIZECNT] = {20, 60, 120, 180, 240};
+int Block::workSizeArr[WORKSIZECNT] = {20};
+
+#include "kNeighbor.def.h"
diff --git a/examples/charm++/load_balancing/kNeighbor/kNeighbor.ci b/examples/charm++/load_balancing/kNeighbor/kNeighbor.ci
new file mode 100644 (file)
index 0000000..080fdc3
--- /dev/null
@@ -0,0 +1,29 @@
+mainmodule kNeighbor {
+  readonly CProxy_Main mainProxy;
+  readonly int num_chares;
+  readonly int gMsgSize;
+  readonly int gLBFreq;
+
+  message toNeighborMsg {
+    int data[];
+  };
+  
+  mainchare Main {
+    entry Main(CkArgMsg *m);
+    entry void nextStep_plain(double);
+    entry void nextStep(CkReductionMsg *);
+    entry void terminate(CkReductionMsg *);
+    entry void resumeIter();
+  };
+
+  array [1D] Block {
+    entry Block();
+    entry void commWithNeighbors();
+    entry void commWithNeighbors(int);
+    entry void recvReplies(toNeighborMsg *);
+    entry void recvMsgs(toNeighborMsg *);
+    entry void printSts(int);
+    entry void pauseForLB();
+  };
+
+}
diff --git a/examples/charm++/load_balancing/stencil3d/Makefile b/examples/charm++/load_balancing/stencil3d/Makefile
new file mode 100644 (file)
index 0000000..7a10e47
--- /dev/null
@@ -0,0 +1,31 @@
+OPTS   = -O3
+CHARMC = ../../../../bin/charmc $(OPTS)
+
+OBJS = stencil3d.o
+
+all: stencil3d
+
+stencil3d: $(OBJS)
+       $(CHARMC) -language charm++ -module CommonLBs -o stencil3d $(OBJS)
+
+projections: $(OBJS)
+       $(CHARMC) -language charm++ -tracemode projections -lz -o stencil3d.prj $(OBJS)
+
+summary: $(OBJS)
+       $(CHARMC) -language charm++ -tracemode summary -lz -o stencil3d.sum $(OBJS)
+
+stencil3d.decl.h: stencil3d.ci
+       $(CHARMC)  stencil3d.ci
+
+stencil3d.o: stencil3d.C stencil3d.decl.h
+       $(CHARMC) -c stencil3d.C
+
+clean:
+       rm -f *.decl.h *.def.h conv-host *.o stencil3d stencil3d.prj charmrun *~
+
+test: stencil3d
+       ./charmrun +p4 ./stencil3d 32 16 +balancer GreedyLB $(TESTOPTS)
+       ./charmrun +p4 ./stencil3d 32 16 +balancer RefineLB $(TESTOPTS)
+
+bgtest: stencil3d
+       ./charmrun +p4 ./stencil3d 32 16 +balancer CommLB +x2 +y2 +z1 +cth1 +wth1
diff --git a/examples/charm++/load_balancing/stencil3d/stencil3d.C b/examples/charm++/load_balancing/stencil3d/stencil3d.C
new file mode 100644 (file)
index 0000000..b728587
--- /dev/null
@@ -0,0 +1,373 @@
+/** \file stencil3d.C
+ *  Author: Abhinav S Bhatele
+ *  Date Created: December 28th, 2010
+ *
+ *  This example is written to be used with periodic measurement-based load
+ *  balancers at sync. The load of some chares changes across iterations and
+ *  depends on the index of the chare.
+ *
+ *
+ *
+ *           *****************
+ *        *               *  *
+ *   ^ *****************     *
+ *   | *               *     *
+ *   | *               *     *
+ *   | *               *     *
+ *   Y *               *     *
+ *   | *               *     *
+ *   | *               *     *
+ *   | *               *  * 
+ *   ~ *****************    Z
+ *     <------ X ------> 
+ *
+ *   X: left, right --> wrap_x
+ *   Y: top, bottom --> wrap_y
+ *   Z: front, back --> wrap_z
+ */
+
+#include "stencil3d.decl.h"
+#include "TopoManager.h"
+
+/*readonly*/ CProxy_Main mainProxy;
+/*readonly*/ int arrayDimX;
+/*readonly*/ int arrayDimY;
+/*readonly*/ int arrayDimZ;
+/*readonly*/ int blockDimX;
+/*readonly*/ int blockDimY;
+/*readonly*/ int blockDimZ;
+
+// specify the number of worker chares in each dimension
+/*readonly*/ int num_chare_x;
+/*readonly*/ int num_chare_y;
+/*readonly*/ int num_chare_z;
+
+static unsigned long next = 1;
+
+int myrand(int numpes) {
+  next = next * 1103515245 + 12345;
+  return((unsigned)(next/65536) % numpes);
+}
+
+// We want to wrap entries around, and because mod operator % 
+// sometimes misbehaves on negative values. -1 maps to the highest value.
+#define wrap_x(a)      (((a)+num_chare_x)%num_chare_x)
+#define wrap_y(a)      (((a)+num_chare_y)%num_chare_y)
+#define wrap_z(a)      (((a)+num_chare_z)%num_chare_z)
+
+#define index(a,b,c)   ((a)+(b)*(blockDimX+2)+(c)*(blockDimX+2)*(blockDimY+2))
+
+#define MAX_ITER       100
+#define LBPERIOD       5
+#define CHANGELOAD     30
+#define LEFT           1
+#define RIGHT          2
+#define TOP            3
+#define BOTTOM         4
+#define FRONT          5
+#define BACK           6
+#define DIVIDEBY7              0.14285714285714285714
+
+double startTime;
+double endTime;
+
+/** \class Main
+ *
+ */
+class Main : public CBase_Main {
+  public:
+    CProxy_Stencil array;
+
+    Main(CkArgMsg* m) {
+      if ( (m->argc != 3) && (m->argc != 7) ) {
+        CkPrintf("%s [array_size] [block_size]\n", m->argv[0]);
+        CkPrintf("OR %s [array_size_X] [array_size_Y] [array_size_Z] [block_size_X] [block_size_Y] [block_size_Z]\n", m->argv[0]);
+        CkAbort("Abort");
+      }
+
+      // store the main proxy
+      mainProxy = thisProxy;
+       
+      if(m->argc == 3) {
+       arrayDimX = arrayDimY = arrayDimZ = atoi(m->argv[1]);
+        blockDimX = blockDimY = blockDimZ = atoi(m->argv[2]); 
+      }
+      else if (m->argc == 7) {
+        arrayDimX = atoi(m->argv[1]);
+       arrayDimY = atoi(m->argv[2]);
+       arrayDimZ = atoi(m->argv[3]);
+        blockDimX = atoi(m->argv[4]); 
+       blockDimY = atoi(m->argv[5]); 
+       blockDimZ = atoi(m->argv[6]);
+      }
+
+      if (arrayDimX < blockDimX || arrayDimX % blockDimX != 0)
+        CkAbort("array_size_X % block_size_X != 0!");
+      if (arrayDimY < blockDimY || arrayDimY % blockDimY != 0)
+        CkAbort("array_size_Y % block_size_Y != 0!");
+      if (arrayDimZ < blockDimZ || arrayDimZ % blockDimZ != 0)
+        CkAbort("array_size_Z % block_size_Z != 0!");
+
+      num_chare_x = arrayDimX / blockDimX;
+      num_chare_y = arrayDimY / blockDimY;
+      num_chare_z = arrayDimZ / blockDimZ;
+
+      // print info
+      CkPrintf("\nSTENCIL COMPUTATION WITH BARRIERS\n");
+      CkPrintf("Running Stencil on %d processors with (%d, %d, %d) chares\n", CkNumPes(), num_chare_x, num_chare_y, num_chare_z);
+      CkPrintf("Array Dimensions: %d %d %d\n", arrayDimX, arrayDimY, arrayDimZ);
+      CkPrintf("Block Dimensions: %d %d %d\n", blockDimX, blockDimY, blockDimZ);
+
+      // Create new array of worker chares
+      array = CProxy_Stencil::ckNew(num_chare_x, num_chare_y, num_chare_z);
+
+      //Start the computation
+      startTime = CmiWallTimer();
+      array.doStep();
+    }
+
+    // Each worker reports back to here when it completes an iteration
+    void report() {
+      CkExit();
+    }
+};
+
+/** \class Stencil
+ *
+ */
+
+class Stencil: public CBase_Stencil {
+  Stencil_SDAG_CODE
+
+  public:
+    int iterations;
+    int imsg;
+
+    double *temperature;
+    double *new_temperature;
+
+    // Constructor, initialize values
+    Stencil() {
+      __sdag_init();
+      usesAtSync = CmiTrue;
+
+      int i, j, k;
+      // allocate a three dimensional array
+      temperature = new double[(blockDimX+2) * (blockDimY+2) * (blockDimZ+2)];
+      new_temperature = new double[(blockDimX+2) * (blockDimY+2) * (blockDimZ+2)];
+
+      for(k=0; k<blockDimZ+2; ++k)
+       for(j=0; j<blockDimY+2; ++j)
+         for(i=0; i<blockDimX+2; ++i)
+           temperature[index(i, j, k)] = 0.0;
+
+      iterations = 0;
+      imsg = 0;
+      constrainBC();
+    }
+
+    void pup(PUP::er &p)
+    {
+      CBase_Stencil::pup(p);
+      __sdag_pup(p);
+      p|iterations;
+      p|imsg;
+
+      size_t size = (blockDimX+2) * (blockDimY+2) * (blockDimZ+2);
+      if (p.isUnpacking()) {
+       temperature = new double[size];
+       new_temperature = new double[size];
+      }
+      p(temperature, size);
+      p(new_temperature, size);
+    }
+
+    Stencil(CkMigrateMessage* m) { __sdag_init(); }
+
+    ~Stencil() { 
+      delete [] temperature; 
+      delete [] new_temperature; 
+    }
+
+    // Send ghost faces to the six neighbors
+    void begin_iteration(void) {
+      iterations++;
+
+      // Copy different faces into messages
+      double *leftGhost =  new double[blockDimY*blockDimZ];
+      double *rightGhost =  new double[blockDimY*blockDimZ];
+      double *topGhost =  new double[blockDimX*blockDimZ];
+      double *bottomGhost =  new double[blockDimX*blockDimZ];
+      double *frontGhost =  new double[blockDimX*blockDimY];
+      double *backGhost =  new double[blockDimX*blockDimY];
+
+      for(int k=0; k<blockDimZ; ++k)
+       for(int j=0; j<blockDimY; ++j) {
+         leftGhost[k*blockDimY+j] = temperature[index(1, j+1, k+1)];
+         rightGhost[k*blockDimY+j] = temperature[index(blockDimX, j+1, k+1)];
+       }
+
+      for(int k=0; k<blockDimZ; ++k)
+       for(int i=0; i<blockDimX; ++i) {
+         topGhost[k*blockDimX+i] = temperature[index(i+1, 1, k+1)];
+         bottomGhost[k*blockDimX+i] = temperature[index(i+1, blockDimY, k+1)];
+       }
+
+      for(int j=0; j<blockDimY; ++j)
+       for(int i=0; i<blockDimX; ++i) {
+         frontGhost[j*blockDimX+i] = temperature[index(i+1, j+1, 1)];
+         backGhost[j*blockDimX+i] = temperature[index(i+1, j+1, blockDimZ)];
+       }
+
+      // Send my left face
+      thisProxy(wrap_x(thisIndex.x-1), thisIndex.y, thisIndex.z)
+         .receiveGhosts(iterations, RIGHT, blockDimY, blockDimZ, leftGhost);
+      // Send my right face
+      thisProxy(wrap_x(thisIndex.x+1), thisIndex.y, thisIndex.z)
+         .receiveGhosts(iterations, LEFT, blockDimY, blockDimZ, rightGhost);
+      // Send my bottom face
+      thisProxy(thisIndex.x, wrap_y(thisIndex.y-1), thisIndex.z)
+         .receiveGhosts(iterations, TOP, blockDimX, blockDimZ, bottomGhost);
+      // Send my top face
+      thisProxy(thisIndex.x, wrap_y(thisIndex.y+1), thisIndex.z)
+         .receiveGhosts(iterations, BOTTOM, blockDimX, blockDimZ, topGhost);
+      // Send my front face
+      thisProxy(thisIndex.x, thisIndex.y, wrap_z(thisIndex.z-1))
+         .receiveGhosts(iterations, BACK, blockDimX, blockDimY, frontGhost);
+      // Send my back face
+      thisProxy(thisIndex.x, thisIndex.y, wrap_z(thisIndex.z+1))
+         .receiveGhosts(iterations, FRONT, blockDimX, blockDimY, backGhost);
+
+      delete[] leftGhost;
+      delete[] rightGhost;
+      delete[] bottomGhost;
+      delete[] topGhost;
+      delete[] frontGhost;
+      delete[] backGhost;
+    }
+
+    void processGhosts(int dir, int height, int width, double gh[]) {
+      switch(dir) {
+       case LEFT:
+         for(int k=0; k<width; ++k)
+           for(int j=0; j<height; ++j) {
+             temperature[index(0, j+1, k+1)] = gh[k*height+j];
+           }
+         break;
+       case RIGHT:
+         for(int k=0; k<width; ++k)
+           for(int j=0; j<height; ++j) {
+             temperature[index(blockDimX+1, j+1, k+1)] = gh[k*height+j];
+           }
+         break;
+       case BOTTOM:
+         for(int k=0; k<width; ++k)
+           for(int i=0; i<height; ++i) {
+             temperature[index(i+1, 0, k+1)] = gh[k*height+i];
+           }
+         break;
+       case TOP:
+         for(int k=0; k<width; ++k)
+           for(int i=0; i<height; ++i) {
+             temperature[index(i+1, blockDimY+1, k+1)] = gh[k*height+i];
+           }
+         break;
+       case FRONT:
+         for(int j=0; j<width; ++j)
+           for(int i=0; i<height; ++i) {
+             temperature[index(i+1, j+1, 0)] = gh[j*height+i];
+           }
+         break;
+       case BACK:
+         for(int j=0; j<width; ++j)
+           for(int i=0; i<height; ++i) {
+             temperature[index(i+1, j+1, blockDimZ+1)] = gh[j*height+i];
+           }
+         break;
+       default:
+          CkAbort("ERROR\n");
+      }
+    }
+
+
+    void check_and_compute() {
+      compute_kernel();
+
+      // calculate error
+      // not being done right now since we are doing a fixed no. of iterations
+
+      double *tmp;
+      tmp = temperature;
+      temperature = new_temperature;
+      new_temperature = tmp;
+
+      constrainBC();
+
+      if(thisIndex.x == 0 && thisIndex.y == 0 && thisIndex.z == 0) {
+       endTime = CmiWallTimer();
+       CkPrintf("[%d] Time per iteration: %f %f\n", iterations, (endTime - startTime), endTime);
+      }
+
+      if(iterations == MAX_ITER)
+       contribute(0, 0, CkReduction::concat, CkCallback(CkIndex_Main::report(), mainProxy));
+      else {
+       startTime = CmiWallTimer();
+       if(iterations % LBPERIOD == 0)
+         AtSync();
+       else
+         contribute(0, 0, CkReduction::concat, CkCallback(CkIndex_Stencil::doStep(), thisProxy));
+      }
+    }
+
+    // Check to see if we have received all neighbor values yet
+    // If all neighbor values have been received, we update our values and proceed
+    void compute_kernel() {
+      int itno = (int)ceil((double)iterations/(double)CHANGELOAD) * 5;
+      int index = thisIndex.x + thisIndex.y*num_chare_x + thisIndex.z*num_chare_x*num_chare_y;
+      int numChares = num_chare_x * num_chare_y * num_chare_z;
+      double work = 100.0;
+
+      if(index >= numChares*0.2 && index <=numChares*0.8) {
+       work = work * ((double)index/(double)numChares) + (double)itno;
+       // CkPrintf("[%d][%d][%d] %d %d %f\n", thisIndex.x, thisIndex.y, thisIndex.z, index, itno, work);
+      } else
+       work = 10.0;
+
+#pragma unroll
+      for(int w=0; w<work; w++) {
+       for(int k=1; k<blockDimZ+1; ++k)
+         for(int j=1; j<blockDimY+1; ++j)
+           for(int i=1; i<blockDimX+1; ++i) {
+             // update my value based on the surrounding values
+             new_temperature[index(i, j, k)] = (temperature[index(i-1, j, k)]
+                                             +  temperature[index(i+1, j, k)]
+                                             +  temperature[index(i, j-1, k)]
+                                             +  temperature[index(i, j+1, k)]
+                                             +  temperature[index(i, j, k-1)]
+                                             +  temperature[index(i, j, k+1)]
+                                             +  temperature[index(i, j, k)] )
+                                             *  DIVIDEBY7;
+           } // end for
+      }
+    }
+
+    // Enforce some boundary conditions
+    void constrainBC() {
+      // Heat left, top and front faces of each chare's block
+      for(int k=1; k<blockDimZ+1; ++k)
+       for(int i=1; i<blockDimX+1; ++i)
+         temperature[index(i, 1, k)] = 255.0;
+      for(int k=1; k<blockDimZ+1; ++k)
+       for(int j=1; j<blockDimY+1; ++j)
+         temperature[index(1, j, k)] = 255.0;
+      for(int j=1; j<blockDimY+1; ++j)
+       for(int i=1; i<blockDimX+1; ++i)
+         temperature[index(i, j, 1)] = 255.0;
+    }
+
+    void ResumeFromSync() {
+      doStep();
+    }
+};
+
+#include "stencil3d.def.h"
diff --git a/examples/charm++/load_balancing/stencil3d/stencil3d.ci b/examples/charm++/load_balancing/stencil3d/stencil3d.ci
new file mode 100644 (file)
index 0000000..d5494d9
--- /dev/null
@@ -0,0 +1,44 @@
+mainmodule stencil3d {
+
+  readonly CProxy_Main mainProxy;
+  readonly int arrayDimX;
+  readonly int arrayDimY;
+  readonly int arrayDimZ;
+  readonly int blockDimX;
+  readonly int blockDimY;
+  readonly int blockDimZ;
+
+  readonly int num_chare_x;
+  readonly int num_chare_y;
+  readonly int num_chare_z;
+
+  mainchare Main {
+    entry Main(CkArgMsg *m);
+    entry void report();
+  };
+
+  array [3D] Stencil {
+    entry Stencil(void);
+    entry void begin_iteration(void);
+    entry void receiveGhosts(int iter, int dir, int height, int width,
+                             double ghosts[height*width]);
+
+    entry void doStep() {
+      atomic "begin_iteration" {
+       begin_iteration();
+      }
+      for(imsg = 0; imsg < 6; imsg++) {
+       // "iterations" keeps track of messages across steps
+       when receiveGhosts[iterations] (int iter, int dir, int height, 
+                                     int width, double ghosts[height*width])
+         atomic "process_ghosts" {
+            processGhosts(dir, height, width, ghosts);
+          }
+      }
+      atomic "do_work" {
+       check_and_compute();
+      }
+    };
+  };
+
+};
diff --git a/examples/charm++/simple_imbalance/LB_Test.C b/examples/charm++/simple_imbalance/LB_Test.C
deleted file mode 100644 (file)
index b92c28f..0000000
+++ /dev/null
@@ -1,182 +0,0 @@
-#include "LB_Test.decl.h"
-
-/*readonly*/ CProxy_Main mainProxy;
-/*readonly*/ int num_chare_blocks;
-/*readonly*/ int workWeight;
-/*readonly*/ int total_iterations;
-
-class Main : public CBase_Main
-{
-public:
-  int report_count;
-  int iter_count;
-  int done_count;
-  CProxy_LB_Test arrayProxy;
-  double timestamp;
-  double workStartTimestamp;
-  double totalChareWorkTime;
-
-  Main(CkArgMsg* m) {
-    CkAssert(CkMyPe() == 0);
-    if ((m->argc < 3) || (m->argc > 4)) {
-      CkPrintf("Usage: %s <num chare blocks/pe> <total iter> [work weight]\n", 
-              m->argv[0]);
-      CkAbort("Abort");
-    }
-    num_chare_blocks = atoi(m->argv[1]);
-    total_iterations = atoi(m->argv[2]);
-    workWeight = 1;
-    if (m->argc == 4) {
-      workWeight = atoi(m->argv[3]);
-    }
-
-    timestamp = CkWallTimer();
-    totalChareWorkTime = 0.0;
-    report_count = 0;
-    iter_count = 0;
-    done_count = 0;
-
-    // store the main proxy
-    mainProxy = thisProxy;
-
-    // print info
-    CkPrintf("Running on %d processors with %d chares per pe\n", 
-            CkNumPes(), num_chare_blocks*4);
-
-    // Create new array of worker chares. The element constructors will
-    // contact this object to start the computation.
-    arrayProxy = CProxy_LB_Test::ckNew(num_chare_blocks*4*CkNumPes());
-
-  }
-
-  void report_in() {
-    report_count++;
-    if (num_chare_blocks*4*CkNumPes() == report_count) {
-      workStartTimestamp = CkWallTimer();
-      CkPrintf("All array elements ready at %f seconds. Computation Begins\n",
-              workStartTimestamp - timestamp);
-      report_count = 0;
-      for (int i=0; i<num_chare_blocks*4*CkNumPes(); i++) {
-       arrayProxy[i].next_iter();
-      }
-    }
-  }
-
-  // Reduction callback client
-  void iterBarrier(double chareWorkTime) {
-    iter_count++;
-    totalChareWorkTime += chareWorkTime;
-    if (num_chare_blocks*4*CkNumPes() == iter_count) {
-      iter_count = 0;
-      for (int i=0; i<num_chare_blocks*4*CkNumPes(); i++) {
-       arrayProxy[i].next_iter();
-      }
-    }
-  }
-
-  // Each worker reports back to here when it completes all work
-  void report_done() {
-    done_count++;
-    if (num_chare_blocks*4*CkNumPes() == done_count) {
-      CkPrintf("Total work performed = %f seconds\n", totalChareWorkTime);
-      CkPrintf("Average total chare work per iteration = %f seconds\n",
-              totalChareWorkTime/total_iterations);
-      CkPrintf("Average iteration time = %f seconds\n",
-              (CkWallTimer() - workStartTimestamp)/total_iterations);
-      CkPrintf("Done after %f seconds\n", CkWallTimer() - timestamp);
-      CkExit();
-    }
-  }
-};
-
-class LB_Test: public CBase_LB_Test {
-public:
-  int iteration;
-  int work_factor;
-
-  // Initialization and start of iterations. 
-  // Chares starting on even-numbered processors get a single work
-  // unit. 
-  // Chares starting on odd-numbered processors get two work units.
-  // NOTE: These work factors do not change after migration! That's
-  //       the point of this example!
-  LB_Test() {
-    if (CkMyPe() % 2 == 0) {
-      work_factor = 1;
-    } else {
-      work_factor = 2;
-    }
-    iteration = 0;
-    usesAtSync = CmiTrue;
-    mainProxy.report_in();
-  }
-
-  // For migration
-  LB_Test(CkMigrateMessage* m) {
-  }
-
-  // Destructor
-  ~LB_Test() {
-  }
-
-  // Load Balancing happens halfway into the computation
-  void next_iter() {
-    if (iteration < total_iterations) {
-      if ((iteration == total_iterations/2) && usesAtSync) {
-       AtSync();
-      } else {
-       compute();
-      }
-    } else {
-      mainProxy.report_done();
-    }
-  }
-
-  void compute() {
-    double timeStamp = CkWallTimer();
-    //    double a[2000], b[2000], c[2000];
-    // This is to get around the tiny default stack size used by the
-    // bigsim emulator on certain machines.
-    double *a;
-    double *b;
-    double *c;
-    a = new double[2000];
-    b = new double[2000];
-    c = new double[2000];
-    for(int j=0;j<1000*work_factor;j++){
-      for(int i=0;i<2000;i++){
-       a[i] = 7.0;
-       b[i] = 5.0;
-      }
-      for(int i=0;i<2000/2;i++){
-       c[i] = a[2*i]*b[2*i+1]*a[i];
-       c[2*i] = a[2*i];
-      }
-    }
-    delete [] a;
-    delete [] b;
-    delete [] c;
-    double timeTaken = CkWallTimer() - timeStamp;
-    // Sanity output
-    if (((iteration == 0) || (iteration == total_iterations-1)) &&
-       ((thisIndex == 0) || (thisIndex == 1))) {
-      CkPrintf("[%d] Array Element %d took %f seconds at iteration %d\n", 
-              CkMyPe(), thisIndex, timeTaken, iteration);
-    }
-    iteration++;
-    mainProxy.iterBarrier(timeTaken);
-  }
-  
-  void ResumeFromSync(void) { // Called by Load-balancing framework
-    compute();
-  }
-  
-  void pup(PUP::er &p)
-  {
-    CBase_LB_Test::pup(p);
-    p | iteration;
-    p | work_factor;
-  }
-};
-
-#include "LB_Test.def.h"
diff --git a/examples/charm++/simple_imbalance/LB_Test.ci b/examples/charm++/simple_imbalance/LB_Test.ci
deleted file mode 100644 (file)
index bae3a12..0000000
+++ /dev/null
@@ -1,19 +0,0 @@
-mainmodule LB_Test {
-  readonly CProxy_Main mainProxy;
-  readonly int num_chare_blocks;
-  readonly int workWeight;
-  readonly int total_iterations;
-
-  mainchare Main {
-    entry Main(CkArgMsg *m);
-    entry void report_in();
-    entry void iterBarrier(double chareWorkTime);
-    entry void report_done();
-  };
-
-  array [1D] LB_Test {
-    // Normal Charm++ entry methods
-    entry LB_Test(void);
-    entry void next_iter();
-  };
-};
diff --git a/examples/charm++/simple_imbalance/Makefile b/examples/charm++/simple_imbalance/Makefile
deleted file mode 100644 (file)
index 890de77..0000000
+++ /dev/null
@@ -1,20 +0,0 @@
-CHARMC=../../../bin/charmc $(OPTS)
-
-OBJS = LB_Test.o
-
-all: LB_Test LB_Test_LB
-
-LB_Test: $(OBJS)
-       $(CHARMC) -language charm++ -o LB_Test $(OBJS)
-
-LB_Test_LB: $(OBJS)
-       $(CHARMC) -language charm++ -o LB_Test_LB -module CommonLBs $(OBJS)
-
-LB_Test.decl.h: LB_Test.ci
-       $(CHARMC)  LB_Test.ci
-
-clean:
-       rm -f *.decl.h *.def.h conv-host *.o LB_Test LB_Test_LB charmrun *~ *.core
-
-LB_Test.o: LB_Test.C LB_Test.decl.h
-       $(CHARMC) -c LB_Test.C
diff --git a/src/QuickThreads/mkfiles/aix64-light b/src/QuickThreads/mkfiles/aix64-light
new file mode 100644 (file)
index 0000000..730e7a4
--- /dev/null
@@ -0,0 +1,20 @@
+CC=../../bin/charmc -I. -ma $(OPTS)
+
+all: qt stp testpgm
+
+qt: md/setjmp_d.h qt.c md/setjmp64_.c
+       rm -f qtmd.h
+       ln -s md/setjmp_d.h qtmd.h
+       $(CC) -c -o qt.o qt.c
+       $(CC) -c -o qtmds.o md/setjmp64_.c
+       $(CC) -o libqt.a qt.o qtmds.o
+       $(CC) -shared -o libqt.so qt.o qtmds.o
+
+stp:
+       $(CC) -c stp.c
+       ar q libstp.a stp.o
+
+testpgm:
+       $(CC) -c meas.c
+       $(CC) -c -o qtmdb.o md/setjmp_b.c
+       $(CC) -o run meas.o qtmdb.o libstp.a libqt.a
index 843b578a6c4356c0973f31529e41490237f3d5c0..3e377ae6bc4e931b1a7f928432fc862377cc4a0e 100644 (file)
@@ -242,9 +242,11 @@ DCMF_Protocol_t  cmi_dcmf_eager_registration __attribute__((__aligned__(16)));
 DCMF_Protocol_t  cmi_dcmf_rzv_registration   __attribute__((__aligned__(16)));
 DCMF_Protocol_t  cmi_dcmf_multicast_registration   __attribute__((__aligned__(16)));
 
-#define BGP_USE_RDMA 1
-/*#define CMI_DIRECT_DEBUG 1*/
-#ifdef BGP_USE_RDMA
+
+#define BGP_USE_AM_DIRECT 1
+//#define BGP_USE_RDMA_DIRECT 1
+//#define CMI_DIRECT_DEBUG 1
+#ifdef BGP_USE_AM_DIRECT
 
 
 DCMF_Protocol_t  cmi_dcmf_direct_registration __attribute__((__aligned__(16)));
@@ -317,6 +319,75 @@ DCMF_Request_t * direct_first_pkt_recv_done (void              * clientdata,
 
 #endif
 
+#ifdef BGP_USE_RDMA_DIRECT
+static struct DCMF_Callback_t dcmf_rdma_cb_ack;
+
+
+DCMF_Protocol_t  cmi_dcmf_direct_put_registration __attribute__((__aligned__(16)));
+
+DCMF_Protocol_t  cmi_dcmf_direct_get_registration __attribute__((__aligned__(16)));
+
+DCMF_Protocol_t  cmi_dcmf_direct_rdma_registration __attribute__((__aligned__(16)));
+/** The receive side of a DCMF_Put notification implemented in DCMF_Send */
+
+typedef struct {
+  void (*callbackFnPtr)(void *);
+    void *callbackData;
+} dcmfDirectRDMAMsgHeader;
+
+
+
+#if (DCMF_VERSION_MAJOR >= 2)
+void direct_send_rdma_done_cb(void*nothing, DCMF_Error_t *err) 
+#else 
+  void direct_send_rdma_done_cb(void*nothing) 
+#endif
+{
+#if CMI_DIRECT_DEBUG
+  CmiPrintf("[%d] RDMA send_rdma_done_cb result %d\n", CmiMyPe());
+#endif
+
+
+}
+
+DCMF_Callback_t  directcb;
+
+void     direct_short_rdma_pkt_recv (void             * clientdata,
+                                const DCQuad     * info,
+                                unsigned           count,
+                                unsigned           senderrank,
+                                const char       * buffer,
+                                const unsigned     sndlen) {
+#if CMI_DIRECT_DEBUG
+    CmiPrintf("[%d] RDMA direct_short_rdma_pkt_recv\n", CmiMyPe());
+#endif
+    dcmfDirectRDMAMsgHeader *msgHead=  (dcmfDirectRDMAMsgHeader *) info;
+    (*(msgHead->callbackFnPtr))(msgHead->callbackData);
+}
+
+
+#if (DCMF_VERSION_MAJOR >= 2)
+typedef void (*cbhdlr) (void *, DCMF_Error_t *);
+#else
+typedef void (*cbhdlr) (void *);
+#endif
+
+DCMF_Request_t * direct_first_rdma_pkt_recv_done (void              * clientdata,
+        const DCQuad      * info,
+        unsigned            count,
+        unsigned            senderrank,
+        const unsigned      sndlen,
+        unsigned          * rcvlen,
+        char             ** buffer,
+        DCMF_Callback_t   * cb
+                                            ) {
+    CmiAbort("direct_first_rdma_pkt_recv should not be called");
+}
+
+
+#endif
+
+
 typedef struct msg_list {
     char              * msg;
     int                 size;
@@ -786,7 +857,7 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
     DCMF_Send_register (&cmi_dcmf_eager_registration, &eager_config);
     DCMF_Send_register (&cmi_dcmf_rzv_registration,   &rzv_config);
 
-#ifdef BGP_USE_RDMA
+#ifdef BGP_USE_AM_DIRECT
     DCMF_Send_Configuration_t direct_config;
     direct_config.protocol      = DCMF_DEFAULT_SEND_PROTOCOL;
     direct_config.cb_recv_short = direct_short_pkt_recv;
@@ -801,6 +872,27 @@ void ConverseInit(int argc, char **argv, CmiStartFn fn, int usched, int initret)
     directcb.clientdata=NULL;
 #endif
 
+#ifdef BGP_USE_RDMA_DIRECT
+    /* notification protocol */
+    DCMF_Send_Configuration_t direct_rdma_config;
+    direct_rdma_config.protocol      = DCMF_DEFAULT_SEND_PROTOCOL;
+    direct_rdma_config.cb_recv_short = direct_short_rdma_pkt_recv;
+    direct_rdma_config.cb_recv       = direct_first_rdma_pkt_recv_done;
+#if (DCMF_VERSION_MAJOR >= 3)
+    direct_rdma_config.network  = DCMF_DEFAULT_NETWORK;
+#elif (DCMF_VERSION_MAJOR == 2)
+    direct_rdma_config.network  = DCMF_DefaultNetwork;
+#endif
+    DCMF_Send_register (&cmi_dcmf_direct_rdma_registration,   &direct_rdma_config);
+    directcb.function=direct_send_rdma_done_cb;
+    directcb.clientdata=NULL;
+    /* put protocol */
+   DCMF_Put_Configuration_t put_configuration = { DCMF_DEFAULT_PUT_PROTOCOL };
+   DCMF_Put_register (&cmi_dcmf_direct_put_registration, &put_configuration);
+   DCMF_Get_Configuration_t get_configuration = { DCMF_DEFAULT_GET_PROTOCOL };
+   DCMF_Get_register (&cmi_dcmf_direct_get_registration, &get_configuration);
+    
+#endif
     //fprintf(stderr, "Initializing Eager Protocol\n");
 
     _Cmi_numnodes = DCMF_Messager_size();
@@ -1993,7 +2085,7 @@ side
 
 
 
-#ifdef BGP_USE_RDMA
+#ifdef BGP_USE_AM_DIRECT
 
 #include "cmidirect.h"
 
@@ -2015,8 +2107,6 @@ side
  To be called on the receiver to create a handle and return its number
 **/
 struct infiDirectUserHandle CmiDirect_createHandle(int senderNode,void *recvBuf, int recvBufSize, void (*callbackFnPtr)(void *), void *callbackData,double initialValue) {
-    /* one-sided primitives would require registration of memory */
-
     /* with two-sided primitives we just bundle the buffer and callback info into the handle so the sender can remind us about it later. */
     struct infiDirectUserHandle userHandle;
     userHandle.handle=1; /* doesn't matter on BG/P*/
@@ -2027,7 +2117,7 @@ struct infiDirectUserHandle CmiDirect_createHandle(int senderNode,void *recvBuf,
     userHandle.initialValue=initialValue;
     userHandle.callbackFnPtr=callbackFnPtr;
     userHandle.callbackData=callbackData;
-    userHandle.DCMF_rq_trecv=ALIGN_16(CmiAlloc(sizeof(DCMF_Request_t)+16));
+    userHandle.DCMF_rq_trecv=(DCMF_Request_t *) ALIGN_16(CmiAlloc(sizeof(DCMF_Request_t)+16));
 #if CMI_DIRECT_DEBUG
     CmiPrintf("[%d] RDMA create addr %p %d callback %p callbackdata %p\n",CmiMyPe(),userHandle.recverBuf,userHandle.recverBufSize, userHandle.callbackFnPtr, userHandle.callbackData);
 #endif
@@ -2045,7 +2135,7 @@ void CmiDirect_assocLocalBuffer(struct infiDirectUserHandle *userHandle,void *se
     /* with two-sided primitives we just record the sender buf in the handle */
     userHandle->senderBuf=sendBuf;
     CmiAssert(sendBufSize==userHandle->recverBufSize);
-    userHandle->DCMF_rq_tsend =ALIGN_16(CmiAlloc(sizeof(DCMF_Request_t)+16));
+    userHandle->DCMF_rq_tsend = (DCMF_Request_t *) ALIGN_16(CmiAlloc(sizeof(DCMF_Request_t)+16));
 #if CMI_DIRECT_DEBUG
     CmiPrintf("[%d] RDMA assoc addr %p %d to receiver addr %p callback %p callbackdata %p\n",CmiMyPe(),userHandle->senderBuf,sendBufSize, userHandle->recverBuf, userHandle->callbackFnPtr, userHandle->callbackData);
 #endif
@@ -2094,6 +2184,287 @@ void CmiDirect_put(struct infiDirectUserHandle *userHandle) {
     }
 }
 
+void CmiDirect_get(struct infiDirectUserHandle *userHandle) {
+    CmiAbort("Not Implemented, switch to #define BGP_USE_RDMA_DIRECT");
+}
+
+/**** up to the user to safely call this */
+void CmiDirect_deassocLocalBuffer(struct infiDirectUserHandle *userHandle)
+{
+    CmiAssert(userHandle->senderNode==_Cmi_mynode);
+#if CMK_SMP
+    DCMF_CriticalSection_enter (0);
+#endif
+    CmiFree(userHandle->DCMF_rq_tsend);
+#if CMK_SMP
+    DCMF_CriticalSection_exit (0);
+#endif
+
+}
+
+/**** up to the user to safely call this */
+void CmiDirect_destroyHandle(struct infiDirectUserHandle *userHandle){
+    CmiAssert(userHandle->recverNode==_Cmi_mynode);
+#if CMK_SMP
+    DCMF_CriticalSection_enter (0);
+#endif
+    CmiFree(userHandle->DCMF_rq_trecv);
+
+#if CMK_SMP
+    DCMF_CriticalSection_exit (0);
+#endif
+}
+
+
+/**** Should not be called the first time *********/
+void CmiDirect_ready(struct infiDirectUserHandle *userHandle) {
+    /* no op on BGP */
+}
+
+/**** Should not be called the first time *********/
+void CmiDirect_readyPollQ(struct infiDirectUserHandle *userHandle) {
+    /* no op on BGP */
+}
+
+/**** Should not be called the first time *********/
+void CmiDirect_readyMark(struct infiDirectUserHandle *userHandle) {
+    /* no op on BGP */
+}
+
+#endif /* BGP_USE_AM_DIRECT*/
+
+#ifdef BGP_USE_RDMA_DIRECT
+
+#include "cmidirect.h"
+
+/* 
+   Notification protocol passes callback function and data in a single
+   quadword.  This occurs in a message triggered by the sender side ack
+   callback and therefore has higher latency than polling, but is guaranteed
+   to be semantically correct.  The latency for a single packet that isn't
+   hitting charm/converse should be pretty minimal, but you could run into
+   sender side progress issues.  The alternative of polling on the out of band
+   byte scheme creates correctness issues in that the data really has to be
+   out of band and you rely on the buffer being written in order.  It also has
+   annoying polling issues.  A third scheme could add a second put to a
+   control region to poll upon and force sequential consistency between
+   puts. Its not really clear that this would be faster or avoid the progress
+   issue since you run into the same issues to enforce that sequential
+   consistency.
+
+   EJB   2011/1/20
+*/
+
+
+/* local function to use the ack as our signal to send a remote notify */
+static void CmiNotifyRemoteRDMA(void *handle, struct DCMF_Error_t *error)
+{
+    struct infiDirectUserHandle *userHandle= (struct infiDirectUserHandle *) handle;
+    dcmfDirectRDMAMsgHeader msgHead;
+    msgHead.callbackFnPtr=userHandle->callbackFnPtr;
+    msgHead.callbackData=userHandle->callbackData;
+#if CMK_SMP
+    DCMF_CriticalSection_enter (0);
+#endif
+#if CMI_DIRECT_DEBUG
+    CmiPrintf("[%d] RDMA notify put addr %p %d to recverNode %d receiver addr %p callback %p callbackdata %p \n",CmiMyPe(),userHandle->senderBuf,userHandle->recverBufSize, userHandle->recverNode,userHandle->recverBuf, userHandle->callbackFnPtr, userHandle->callbackData);
+#endif
+    DCMF_Result res=DCMF_Send (&cmi_dcmf_direct_rdma_registration,
+              userHandle->DCMF_rq_tsend,
+              directcb, DCMF_MATCH_CONSISTENCY, userHandle->recverNode,
+              sizeof(dcmfDirectRDMAMsgHeader), 
+
+                              userHandle->DCMF_notify_buf,
+              (struct DCQuad *) &(msgHead), 1);
+//    CmiAssert(res==DCMF_SUCCESS);
+#if CMK_SMP
+    DCMF_CriticalSection_exit (0);
+#endif    
+}
+
+/**
+ To be called on the receiver to create a handle and return its number
+**/
+
+
+struct infiDirectUserHandle CmiDirect_createHandle(int senderNode,void *recvBuf, int recvBufSize, void (*callbackFnPtr)(void *), void *callbackData,double initialValue) {
+    /* one-sided primitives require registration of memory */
+    struct infiDirectUserHandle userHandle;
+    size_t numbytesRegistered=0;
+    DCMF_Result regresult=DCMF_Memregion_create( &userHandle.DCMF_recverMemregion,
+                                                &numbytesRegistered,
+                                                recvBufSize,
+                                                recvBuf,
+                                                0);
+    CmiAssert(numbytesRegistered==recvBufSize);
+    CmiAssert(regresult==DCMF_SUCCESS);
+    
+
+    userHandle.handle=1; /* doesn't matter on BG/P*/
+    userHandle.senderNode=senderNode;
+    userHandle.recverNode=_Cmi_mynode;
+    userHandle.recverBufSize=recvBufSize;
+    userHandle.recverBuf=recvBuf;
+    userHandle.initialValue=initialValue;
+    userHandle.callbackFnPtr=callbackFnPtr;
+    userHandle.callbackData=callbackData;
+    userHandle.DCMF_rq_trecv=(DCMF_Request_t *) ALIGN_16(CmiAlloc(sizeof(DCMF_Request_t)+16));
+#if CMI_DIRECT_DEBUG
+    CmiPrintf("[%d] RDMA create addr %p %d callback %p callbackdata %p\n",CmiMyPe(),userHandle.recverBuf,userHandle.recverBufSize, userHandle.callbackFnPtr, userHandle.callbackData);
+#endif
+    return userHandle;
+}
+
+/****
+ To be called on the sender to attach the sender's buffer to this handle
+******/
+
+void CmiDirect_assocLocalBuffer(struct infiDirectUserHandle *userHandle,void *sendBuf,int sendBufSize) {
+    /* one-sided primitives would require registration of memory */
+    userHandle->senderBuf=sendBuf;
+    CmiAssert(sendBufSize==userHandle->recverBufSize);
+    userHandle->DCMF_rq_tsend =(DCMF_Request_t *) ALIGN_16(CmiAlloc(sizeof(DCMF_Request_t)+16));
+    size_t numbytesRegistered=0;  // set as return value from create
+    userHandle->DCMF_notify_buf=ALIGN_16(CmiAlloc(sizeof(DCMF_Request_t)+32));
+    userHandle->DCMF_notify_cb.function=CmiNotifyRemoteRDMA; 
+    userHandle->DCMF_notify_cb.clientdata=userHandle;
+    DCMF_Result regresult=DCMF_Memregion_create( &userHandle->DCMF_senderMemregion,
+                                                &numbytesRegistered,
+                                                sendBufSize,
+                                                sendBuf,
+                                                0);
+    CmiAssert(numbytesRegistered==sendBufSize);
+    CmiAssert(regresult==DCMF_SUCCESS);
+
+#if CMI_DIRECT_DEBUG
+    CmiPrintf("[%d] RDMA assoc addr %p %d to receiver addr %p callback %p callbackdata %p\n",CmiMyPe(),userHandle->senderBuf,sendBufSize, userHandle->recverBuf, userHandle->callbackFnPtr, userHandle->callbackData);
+#endif
+
+}
+
+
+/****
+To be called on the sender to do the actual data transfer
+******/
+void CmiDirect_put(struct infiDirectUserHandle *userHandle) {
+    /** invoke a DCMF_Put with the direct callback */
+
+    CmiAssert(userHandle->recverBuf!=NULL);
+    CmiAssert(userHandle->senderBuf!=NULL);
+    CmiAssert(userHandle->recverBufSize>0);
+    if (userHandle->recverNode== _Cmi_mynode) {     /* local copy */
+#if CMI_DIRECT_DEBUG
+        CmiPrintf("[%d] RDMA local put addr %p %d to recverNode %d receiver addr %p callback %p callbackdata %p\n",CmiMyPe(),userHandle->senderBuf,userHandle->recverBufSize, userHandle->recverNode,userHandle->recverBuf, userHandle->callbackFnPtr, userHandle->callbackData);
+#endif
+
+        CmiMemcpy(userHandle->recverBuf,userHandle->senderBuf,userHandle->recverBufSize);
+        (*(userHandle->callbackFnPtr))(userHandle->callbackData);
+    } else {
+#if CMK_SMP
+        DCMF_CriticalSection_enter (0);
+#endif
+#if CMI_DIRECT_DEBUG
+        CmiPrintf("[%d] RDMA put addr %p %d to recverNode %d receiver addr %p callback %p callbackdata %p\n",CmiMyPe(),userHandle->senderBuf,userHandle->recverBufSize, userHandle->recverNode,userHandle->recverBuf, userHandle->callbackFnPtr, userHandle->callbackData);
+#endif
+       DCMF_Result 
+           Res= DCMF_Put(&cmi_dcmf_direct_put_registration,
+                         userHandle->DCMF_rq_tsend,
+                         directcb, DCMF_RELAXED_CONSISTENCY, 
+                         userHandle->recverNode,
+                         userHandle->recverBufSize,
+                         &userHandle->DCMF_senderMemregion,
+                         &userHandle->DCMF_recverMemregion,
+                         0, /* offsets are zero */
+                         0, 
+                         userHandle->DCMF_notify_cb
+                         );
+       CmiAssert(Res==DCMF_SUCCESS); 
+#if CMK_SMP
+        DCMF_CriticalSection_exit (0);
+#endif
+    }
+}
+
+/****
+To be called on the receiver to initiate the actual data transfer
+******/
+void CmiDirect_get(struct infiDirectUserHandle *userHandle) {
+    /** invoke a DCMF_Get with the direct callback */
+
+    CmiAssert(userHandle->recverBuf!=NULL);
+    CmiAssert(userHandle->senderBuf!=NULL);
+    CmiAssert(userHandle->recverBufSize>0);
+    if (userHandle->recverNode== _Cmi_mynode) {     /* local copy */
+#if CMI_DIRECT_DEBUG
+        CmiPrintf("[%d] RDMA local get addr %p %d to recverNode %d receiver addr %p callback %p callbackdata %p\n",CmiMyPe(),userHandle->senderBuf,userHandle->recverBufSize, userHandle->recverNode,userHandle->recverBuf, userHandle->callbackFnPtr, userHandle->callbackData);
+#endif
+
+        CmiMemcpy(userHandle->senderBuf,userHandle->recverBuf,userHandle->recverBufSize);
+        (*(userHandle->callbackFnPtr))(userHandle->callbackData);
+    } else {
+        struct DCMF_Callback_t done_cb;
+       done_cb.function=userHandle->callbackFnPtr;
+       done_cb.clientdata=userHandle->callbackData;
+#if CMK_SMP
+        DCMF_CriticalSection_enter (0);
+#endif
+#if CMI_DIRECT_DEBUG
+        CmiPrintf("[%d] RDMA get addr %p %d to recverNode %d receiver addr %p callback %p callbackdata %p\n",CmiMyPe(),userHandle->senderBuf,userHandle->recverBufSize, userHandle->recverNode,userHandle->recverBuf, userHandle->callbackFnPtr, userHandle->callbackData);
+#endif
+       DCMF_Result 
+           Res= DCMF_Get(&cmi_dcmf_direct_get_registration,
+                         (DCMF_Request_t *) userHandle->DCMF_rq_tsend,
+                         done_cb, DCMF_RELAXED_CONSISTENCY, 
+                         userHandle->recverNode,
+                         userHandle->recverBufSize,
+                         & userHandle->DCMF_recverMemregion,
+                         & userHandle->DCMF_senderMemregion,
+                         0, /* offsets are zero */
+                         0
+                         );
+       CmiAssert(Res==DCMF_SUCCESS); 
+
+
+#if CMK_SMP
+        DCMF_CriticalSection_exit (0);
+#endif
+    }
+}
+
+/**** up to the user to safely call this */
+void CmiDirect_deassocLocalBuffer(struct infiDirectUserHandle *userHandle)
+{
+    CmiAssert(userHandle->senderNode==_Cmi_mynode);
+#if CMK_SMP
+    DCMF_CriticalSection_enter (0);
+#endif
+
+    DCMF_Memregion_destroy((DCMF_Memregion_t*) userHandle->DCMF_senderMemregion);
+    CmiFree(userHandle->DCMF_notify_buf);
+    CmiFree(userHandle->DCMF_rq_tsend);
+#if CMK_SMP
+    DCMF_CriticalSection_exit (0);
+#endif
+
+}
+
+/**** up to the user to safely call this */
+void CmiDirect_destroyHandle(struct infiDirectUserHandle *userHandle){
+    CmiAssert(userHandle->recverNode==_Cmi_mynode);
+#if CMK_SMP
+    DCMF_CriticalSection_enter (0);
+#endif
+
+    DCMF_Memregion_destroy((DCMF_Memregion_t*) userHandle->DCMF_recverMemregion);
+    CmiFree(userHandle->DCMF_rq_trecv);
+
+#if CMK_SMP
+    DCMF_CriticalSection_exit (0);
+#endif
+}
+
+
+
 /**** Should not be called the first time *********/
 void CmiDirect_ready(struct infiDirectUserHandle *userHandle) {
     /* no op on BGP */
@@ -2109,5 +2480,5 @@ void CmiDirect_readyMark(struct infiDirectUserHandle *userHandle) {
     /* no op on BGP */
 }
 
-#endif /* BGP_USE_RDMA*/
+#endif /* BGP_USE_RDMA_DIRECT*/
 
index 35b5eb2efdb9eb023dee2aa8cbcc80e79592844e..a5c32d56ee8c62609cb3915a9c13497f679c0926 100644 (file)
@@ -13,5 +13,5 @@ CMK_CF90_FIXED='mpxlf90_r -q64 '
 CMK_C_OPTIMIZE='-O3 -qstrict -qnohot '
 CMK_CXX_OPTIMIZE='-O3 -qstrict -qnohot '
 CMK_AR='ar -X 64 cq'
-CMK_QT='aix64'
+CMK_QT='aix64-light'
 CMK_NM='nm -X 64'
index 8335555799026ed7df8fc6adcae3bcd9ff82c83b..28a9a69d61f18aeee8590bfe0cabb6ea4f8c814b 100644 (file)
@@ -26,7 +26,7 @@ CMK_LD="mpcc_r -q32 -brtl "
 CMK_LDXX="mpCC_r -q32 -brtl "
 if test $isAIX = true
 then
-CMK_QT='aix'
+CMK_QT='aix-light'
 CMK_LIBS="-lckqt -lhC -llapi_r"
 else
 CMK_QT='generic'
index f49ef1f89dad345c3251480f000b1917e43f1568..1ecaa02539ab9a35e4c4037bb42d298baaca4430 100644 (file)
@@ -20,6 +20,7 @@ g++)   CMK_AMD64="-m64 -fPIC" ;;
 icpc)  CMK_AMD64="-m64";;
 pgCC)  CMK_AMD64="-DCMK_CC_PGCC=1" ;;
 esac
+CMK_REAL_C_COMPILER=`$MPICC -show 2>/dev/null | cut -d' ' -f1 `
 
 CMK_CPP_CHARM="/lib/cpp -P"
 CMK_CPP_C="$MPICC -E"
@@ -29,10 +30,11 @@ CMK_CXXPP="$MPICXX -E $CMK_AMD64 "
 CMK_LD="$CMK_CC "
 CMK_LDXX="$CMK_CXX "
 
-CMK_NATIVE_CC="$CMK_CC"
-CMK_NATIVE_LD="$CMK_LD"
-CMK_NATIVE_CXX="$CMK_CXX"
-CMK_NATIVE_LDXX="$CMK_LDXX"
+CMK_NATIVE_CC="$CMK_REAL_C_COMPILER $CMK_AMD64 "
+CMK_NATIVE_LD="$CMK_REAL_C_COMPILER $CMK_AMD64 "
+CMK_NATIVE_CXX="$CMK_REAL_COMPILER $CMK_AMD64 "
+CMK_NATIVE_LDXX="$CMK_REAL_COMPILER $CMK_AMD64 "
+CMK_NATIVE_LIBS=""
 
 # fortran compiler 
 # for Intel Fortran compiler 8.0 and higher which is renamed to ifort from ifc
index 619d7591228e5be39fadecb11e4b137c4821bb87..ab3831fd21287b380dcf1c3bc176f9a5a20db1ca 100644 (file)
@@ -1686,17 +1686,18 @@ int req_reply_child(SOCKET fd, char *type,
                return status;
 }
 #endif
-/* This is the only place where charmrun talks back to anyone. 
-*/
+/**
+ * @brief This is the only place where charmrun talks back to anyone. 
+ */
 int req_reply(SOCKET fd, char *type, 
              const char *data, int dataLen)
 {
-  ChMessageHeader msg;
-  if (fd == INVALID_SOCKET) return REQ_FAILED;
-  ChMessageHeader_new(type,dataLen,&msg);
-  skt_sendN(fd,(const char *)&msg,sizeof(msg));
-  skt_sendN(fd,data,dataLen);
-  return REQ_OK;
+       ChMessageHeader msg;
+       if (fd == INVALID_SOCKET) return REQ_FAILED;
+       ChMessageHeader_new(type,dataLen,&msg);
+       skt_sendN(fd,(const char *)&msg,sizeof(msg));
+       skt_sendN(fd,data,dataLen);
+       return REQ_OK;
 }
 
 /* Request handlers:
@@ -1731,9 +1732,10 @@ int req_handle_initnode(ChMessage *msg,SOCKET fd)
   return REQ_OK;
 }
 
-/*Get the array of node numbers, IPs, and ports.
-This is used by the node-programs to talk to one another.
-*/
+/**
+ * @brief Gets the array of node numbers, IPs, and ports. This is used by the node-programs 
+ * to talk to one another.
+ */
 int req_handle_initnodetab(ChMessage *msg,SOCKET fd)
 {
        ChMessageHeader hdr;
@@ -2006,7 +2008,7 @@ int req_handle_scanf(ChMessage *msg,SOCKET fd)
 #ifdef __FAULT__       
 void restart_node(int crashed_node);
 void reconnect_crashed_client(int socket_index,int crashed_node);
-void anounce_crash(int socket_index,int crashed_node);
+void announce_crash(int socket_index,int crashed_node);
 
 static int _last_crash = 0;                    /* last crashed pe number */
 static int _crash_socket_index = 0;            /* last restart socket */
@@ -2020,6 +2022,10 @@ static int numCrashes=0;  /*number of crashes*/
 static SOCKET last_crashed_fd=-1;
 #endif
 
+/**
+ * @brief Handles an ACK after a crash. Once it has received all the pending acks, it sends the nodetab
+ * table to the crashed node.
+ */
 int req_handle_crashack(ChMessage *msg,SOCKET fd)
 {
        static int count = 0;
@@ -2043,19 +2049,16 @@ int req_handle_crashack(ChMessage *msg,SOCKET fd)
     else
                        
 #endif
-                 if (count == req_nClients-1) {
-                       /* only after everybody else update its nodetab, can this
-                          restarted process continue */
-                       printf("Charmrun> continue node: %d\n", _last_crash);
-                       req_handle_initnodetab(NULL,req_clients[_crash_socket_index]);
-                       
-                       
-                       _last_crash = 0;
-                       count = 0;
+       if (count == req_nClients-1) {
+               // only after everybody else update its nodetab, can this restarted process continue 
+               printf("Charmrun> continue node: %d\n", _last_crash);
+               req_handle_initnodetab(NULL,req_clients[_crash_socket_index]);  
+               _last_crash = 0;
+               count = 0;
 #if (defined(_FAULT_MLOG_) || defined(_FAULT_CAUSAL_))
-       last_crashed_fd=-1;
+                       last_crashed_fd=-1;
 #endif
-  }
+       }
 }
 
 #ifdef HSTART
@@ -2111,7 +2114,7 @@ int req_handle_crashack(ChMessage *msg,SOCKET fd)
                        }
                        
                        /*Anounce crash to all child charmruns*/
-                       anounce_crash(nodetab_rank0_size+1,crashed_node );
+                       announce_crash(nodetab_rank0_size+1,crashed_node );
 
                }
 
@@ -2158,7 +2161,7 @@ void error_in_req_serve_client(SOCKET fd){
        crashed_node = i;
        
        /** should also send a message to all the other processors telling them that this guy has crashed*/
-       /*anounce_crash(socket_index,crashed_node);*/
+       /*announce_crash(socket_index,crashed_node);*/
        restart_node(crashed_node);
 
        fprintf(stdout,"charmrun says Processor %d failed on Node %d\n",crashed_pe,crashed_node);
@@ -2341,16 +2344,14 @@ void req_forward_client()
        }
 #ifdef __FAULT__
        if(strcmp(cmd, "initnodetab") ==0){
-       
                if(_last_crash ==0 ) 
-                               cur_restart_phase++;
+                       cur_restart_phase++;
                int i;
                for (i=0;i<req_nClients;i++)
                        if(_last_crash==0 || i !=_crash_socket_index)
-      if (REQ_OK != req_reply(req_clients[i],cmd,msg.data,ChMessageInt(msg.header.len)))
-          {
-               abort();
-      }
+                               if (REQ_OK != req_reply(req_clients[i],cmd,msg.data,ChMessageInt(msg.header.len))){
+                                       abort();
+                               }
                return;
        }
 
@@ -4634,6 +4635,9 @@ int cur_restart_phase = 1;
 void refill_nodetab_entry(int crashed_node);
 nodetab_host *replacement_host(int pe);
 
+/**
+ * @brief Relaunches a program on the crashed node.
+ */
 void restart_node(int crashed_node){
        int pe = nodetab_rank0_table[crashed_node];
        FILE *f;
@@ -4729,6 +4733,11 @@ nodetab_host *replacement_host(int pe){
 }
 #endif
 
+/**
+ * @brief Reconnects a crashed node. It waits for the I-tuple from the just relaunched program. It also:
+ * i) Broadcast the nodetabtable to every other node.
+ * ii) Announces the crash to every other node.
+ */
 void reconnect_crashed_client(int socket_index,int crashed_node){
        int i;
        unsigned int clientPort;
@@ -4765,6 +4774,7 @@ void reconnect_crashed_client(int socket_index,int crashed_node){
                  fprintf(stderr,"Charmrun: possibly because: %s.\n", msg.data);
                }
 fprintf(stdout,"socket_index %d crashed_node %d reconnected fd %d  \n",socket_index,crashed_node,req_clients[socket_index]);
+
                /** update the nodetab entry corresponding to
                this node, skip the restarted one */
                in = (ChSingleNodeinfo *)msg.data;
@@ -4776,7 +4786,7 @@ fprintf(stdout,"socket_index %d crashed_node %d reconnected fd %d  \n",socket_in
                }
 
                /* tell every one there is a crash */
-               anounce_crash(socket_index,crashed_node);
+               announce_crash(socket_index,crashed_node);
                if (_last_crash != 0) {
                  fprintf(stderr, "ERROR> Charmrun detected multiple crashes.\n");
                          exit(1);
@@ -4792,7 +4802,11 @@ fprintf(stdout,"socket_index %d crashed_node %d reconnected fd %d  \n",socket_in
        }       
 }
 
-void anounce_crash(int socket_index,int crashed_node){
+/**
+ * @brief Sends a message announcing the crash to every other node. This message will be used to
+ * trigger fault tolerance methods.
+ */
+void announce_crash(int socket_index,int crashed_node){
        int i;
        ChMessageHeader hdr;
        ChMessageInt_t crashNo=ChMessageInt_new(crashed_node);
index f2c6a1ced043730bdc0e1a01b0dfdfae1446f077..1e776bc45508ba2726747743132f4f79b49438bc 100644 (file)
@@ -1,5 +1,9 @@
 extern void (*notify_crash_fn)(int);
 
+/**
+ * @brief Handles the crash announcement message.
+ * For double in-memory checkpoint, it calls the notify crash function.
+ */
 static void crash_node_handle(ChMessage *m){
        ChMessageInt_t *d = (ChMessageInt_t *)m->data;
        int crashed_node = ChMessageInt(d[0]);
index 5a159fb429bfbe9624916e1fb4de17b0f90dce22..efcac0a5afdcf61230201b3a1f49569e57c87578 100644 (file)
@@ -5,7 +5,10 @@
 
 #define CkDirect_createHandle CmiDirect_createHandle
 #define CkDirect_assocLocalBuffer CmiDirect_assocLocalBuffer
+#define CkDirect_deassocLocalBuffer CmiDirect_deassocLocalBuffer
+#define CkDirect_destroyHandle CmiDirect_destroyHandle
 #define CkDirect_put CmiDirect_put
+#define CkDirect_get CmiDirect_get
 #define CkDirect_ready CmiDirect_ready
 
 PUPbytes(infiDirectUserHandle)
index 39ef036d6427ea3749c08b70c41b36a04d6f42b2..5d3aeb1ce1db656e735998dd3c9c114e0ca473e9 100644 (file)
@@ -246,7 +246,8 @@ public:
 class arrayMapInfo {
 public:
   CkArrayIndexMax _nelems;
-  int _binSize;                        /* floor of numChares/numPes */
+  int _binSizeFloor;           /* floor of numChares/numPes */
+  int _binSizeCeil;            /* ceiling of numChares/numPes */
   int _numChares;              /* initial total number of chares */
   int _remChares;              /* numChares % numPes -- equals the number of
                                   processors in the first set */
@@ -264,7 +265,7 @@ public:
 
   ~arrayMapInfo() {}
   
-  int compute_binsize()
+  void compute_binsize()
   {
     int numPes = CkNumPes();
 
@@ -277,15 +278,15 @@ public:
     }
 
     _remChares = _numChares % numPes;
-    _binSize = (int)floor((double)_numChares/(double)numPes);
-    _numFirstSet = _remChares * (_binSize + 1);
-
-    return _binSize;
+    _binSizeFloor = (int)floor((double)_numChares/(double)numPes);
+    _binSizeCeil = (int)ceil((double)_numChares/(double)numPes);
+    _numFirstSet = _remChares * (_binSizeFloor + 1);
   }
 
   void pup(PUP::er& p){
     p|_nelems;
-    p|_binSize;
+    p|_binSizeFloor;
+    p|_binSizeCeil;
     p|_numChares;
     p|_remChares;
     p|_numFirstSet;
@@ -331,14 +332,17 @@ public:
       flati = i.data()[0] * amaps[arrayHdl]->_nelems.data()[1] + i.data()[1];
     } else if (i.nInts == 3) {
       flati = (i.data()[0] * amaps[arrayHdl]->_nelems.data()[1] + i.data()[1]) * amaps[arrayHdl]->_nelems.data()[2] + i.data()[2];
-    } else {
+    }
+#if CMK_ERROR_CHECKING
+    else {
       CkAbort("CkArrayIndex has more than 3 integers!");
     }
+#endif
 
     if(flati < amaps[arrayHdl]->_numFirstSet)
-      return (flati / (amaps[arrayHdl]->_binSize + 1));
+      return (flati / (amaps[arrayHdl]->_binSizeFloor + 1));
     else if (flati < amaps[arrayHdl]->_numChares)
-      return (amaps[arrayHdl]->_remChares + (flati - amaps[arrayHdl]->_numFirstSet) / (amaps[arrayHdl]->_binSize));
+      return (amaps[arrayHdl]->_remChares + (flati - amaps[arrayHdl]->_numFirstSet) / (amaps[arrayHdl]->_binSizeFloor));
     else
       return (flati % CkNumPes());
   }
@@ -388,13 +392,16 @@ public:
       flati = i.data()[0] * amaps[arrayHdl]->_nelems.data()[1] + i.data()[1];
     } else if (i.nInts == 3) {
       flati = (i.data()[0] * amaps[arrayHdl]->_nelems.data()[1] + i.data()[1]) * amaps[arrayHdl]->_nelems.data()[2] + i.data()[2];
-    } else {
+    }
+#if CMK_ERROR_CHECKING
+    else {
       CkAbort("CkArrayIndex has more than 3 integers!");
     }
+#endif
 
-    /** binSize calculated in DefaultArrayMap is the floor of numChares/numPes
+    /** binSize used in DefaultArrayMap is the floor of numChares/numPes
      *  but for this FastArrayMap, we need the ceiling */
-    return (flati / (amaps[arrayHdl]->_binSize + 1));
+    return (flati / amaps[arrayHdl]->_binSizeCeil);
   }
 
   void pup(PUP::er& p){
index 7212b21ccba129ab930f5ada72d6b7c4ca99343b..4882531d132950677fa2327aadd0445c18454479 100644 (file)
@@ -1187,9 +1187,14 @@ void notify_crash(int node)
 {
 #ifdef CMK_MEM_CHECKPOINT
   crashed_node = node;
-  CmiAssert(CmiMyPe() != crashed_node);
+  CmiAssert(CmiMyNode() != crashed_node);
   CkMemCheckPT::inRestarting = 1;
 
+#ifdef CMK_SMP
+       // @TODO: this code is temporary. It just makes the SMP charmrun to restart without problems.
+       return;
+#endif
+
     // this may be in interrupt handler, send a message to reset QD
   char *msg = (char*)CmiAlloc(CmiMsgHeaderSizeBytes);
   CmiSetHandler(msg, notifyHandlerIdx);
@@ -1256,7 +1261,7 @@ void readKillFile(){
         int proc;
         double sec;
         while(fscanf(fp,"%d %lf",&proc,&sec)==2){
-                if(proc == CkMyPe()){
+                if(proc == CkMyNode() && CkMyRank() == 0){
                         killTime = CmiWallTimer()+sec;
                         printf("[%d] To be killed after %.6lf s (MEMCKPT) \n",CkMyPe(),sec);
                         CcdCallFnAfter(killLocal,NULL,sec*1000);
index c649759d33c9a98901886ef2e6e996c2fb0a5ac2..a41f51b90814644531837339d2d0090ae3f50abd 100644 (file)
@@ -19,17 +19,16 @@ ProcArray::ProcArray(BaseLB::LDStats *stats) {
   // fill the processor array
   procs.resize(numPes);
 
+  // Loop through the LDStats structure, copying data into this array and calculating
+  //   the average 'totalLoad' of all the PEs
+  avgLoad = 0.0;
   for(int pe = 0; pe < numPes; pe++) {
     procs[pe].id        = stats->procs[pe].pe;
     procs[pe].overhead  = stats->procs[pe].bg_walltime;
     procs[pe].totalLoad = stats->procs[pe].total_walltime - stats->procs[pe].idletime;
     procs[pe].available = stats->procs[pe].available;
-  }
-
-  avgLoad = 0.0;
-
-  for(int pe = 0; pe < numPes; pe++)
     avgLoad += procs[pe].totalLoad;
+  }
   avgLoad /= numPes;
 }
 
index f0e3cfd540ab992e6001ad4c346181a94aa29630..968513e970a290ddfcc86252cd6693ee78edc0e8 100644 (file)
@@ -10,22 +10,32 @@ typedef struct {
 /* is equivalent to DCQUAD, but without including dmcf.h */
 #endif
 
+
 /* handle type definition */
+/* sender is the one who initiates the request.
+   recver is the one who receives the request.
+   Put: sender=source recver=target of the one-sided buffer operation
+   Get: sender=target recver=source of the one-sided buffer operation
+*/
+#ifdef CMK_BLUEGENEP
+#include "dcmf.h"
+#endif
 struct infiDirectUserHandle{
-       int handle;
-       int senderNode;
-       int recverNode;
-       void *recverBuf;
-       int recverBufSize;
+    int handle;
+    int senderNode;
+    int recverNode;
+    void *recverBuf;
+    int recverBufSize;
 #ifdef CMK_BLUEGENEP
     void *senderBuf;
     void (*callbackFnPtr)(void *);
     void *callbackData;
-    /*DCMF_Request_t *DCMF_rq_t;*/
-    void  *DCMF_rq_trecv;
-#endif
-#ifdef CMK_BLUEGENEP
-       void *DCMF_rq_tsend;
+    void *DCMF_notify_buf;
+    DCMF_Request_t *DCMF_rq_trecv;
+    DCMF_Request_t *DCMF_rq_tsend;
+    DCMF_Memregion_t DCMF_recverMemregion;
+    DCMF_Memregion_t DCMF_senderMemregion;
+    DCMF_Callback_t DCMF_notify_cb;
 #else
        char recverKey[64];
 #endif
@@ -48,11 +58,24 @@ struct infiDirectUserHandle CmiDirect_createHandle(int senderNode,void *recvBuf,
 ******/
 void CmiDirect_assocLocalBuffer(struct infiDirectUserHandle *userHandle,void *sendBuf,int sendBufSize);
 
+
+/**** up to the user to safely call this */
+void CmiDirect_deassocLocalBuffer(struct infiDirectUserHandle *userHandle);
+
+/**** up to the user to safely call this */
+void CmiDirect_destroyHandle(struct infiDirectUserHandle *userHandle);
+
 /****
 To be called on the sender to do the actual data transfer
 ******/
 void CmiDirect_put(struct infiDirectUserHandle *userHandle);
 
+
+/****
+To be called on the receiver to initiate the actual data transfer
+******/
+void CmiDirect_get(struct infiDirectUserHandle *userHandle);
+
 /**** Should not be called the first time *********/
 void CmiDirect_ready(struct infiDirectUserHandle *userHandle);
 
index 6bf42c8a717f6cab1f845b4dbe91c90d55f1e85d..988c95ed75a764dafaa731d7b78be29653efed1b 100644 (file)
@@ -8,7 +8,9 @@
 #include <iostream>
 #include <algorithm>
 #include <charm++.h>
+#if CMK_HAS_CBLAS
 #include <cblas.h>
+#endif
 
 namespace CharjArray {
   class Range {
@@ -234,6 +236,7 @@ namespace CharjArray {
       ret += v1[i] * v2[i];
     return ret;
   }
+#if CMK_HAS_CBLAS
   template <>
   float dot<float, RowMajor<1>, RowMajor<1> >(const Vector<float, RowMajor<1> > *pv1,
                                              const Vector<float, RowMajor<1> > *pv2)
@@ -250,6 +253,7 @@ namespace CharjArray {
     assert(v1.size() == v2.size());
     return cblas_ddot(v1.size(), &(v1[0]), 1, &(v2[0]), 1);
   }
+#endif
 
   /// Computer the 1-norm of the given vector
   template<typename T, class atype>
@@ -276,6 +280,7 @@ namespace CharjArray {
       ret += v[i] * v[i];
     return sqrt(ret);
   }
+#if CMK_HAS_CBLAS
   template<>
     float norm2<float, RowMajor<1> >(const Vector<float, RowMajor<1> > *pv)
   {
@@ -288,6 +293,7 @@ namespace CharjArray {
     const Vector<double, RowMajor<1> > &v = *pv;
     return cblas_dnrm2(v.size(), &(v[0]), 1);
   }
+#endif
 
   /// Compute the infinity (max) norm of the given vector
   // Will fail on zero-length vectors
@@ -311,6 +317,7 @@ namespace CharjArray {
     for (int i = 0; i < size; ++i)
       v[i] = t * v[i];
   }
+#if CMK_HAS_CBLAS
   template<>
     void scale<float, float, RowMajor<1> >(const float &t,
                                           Vector<float, RowMajor<1> > *pv)
@@ -325,6 +332,7 @@ namespace CharjArray {
     Vector<double, RowMajor<1> > &v = *pv;
     cblas_dscal(v.size(), t, &(v[0]), 1);
   }
+#endif
 
   /// Add one vector to a scaled version of another
   template<typename T, typename U, class atype>
@@ -337,6 +345,7 @@ namespace CharjArray {
     for (int i = 0; i < size; ++i)
       x[i] = a * x[i] + y[i];
   }
+#if CMK_HAS_CBLAS
   template<>
     void axpy<float, float, RowMajor<1> >(const float &a,
                                          const Vector<float, RowMajor<1> > *px,
@@ -359,6 +368,7 @@ namespace CharjArray {
     assert(size == y.size());
     cblas_daxpy(size, a, &(x[0]), 1, &(y[0]), 1);
   }
+#endif
 }
 
 #endif
index 997518c7ec1a7d10b7eac636a460454a7997d84d..a1d627fad705bfe1e44c10d01a0a5d67ebce45d9 100644 (file)
@@ -1,26 +1,30 @@
-CDIR=../../../..
+CDIR    = ../../../..
 
 CUDADIR = /usr/local/cuda
 CUDASDK = $(HOME)/TOPS-Tesla/NVIDIA_CUDA_SDK
-CUDAC = nvcc 
+CUDAC   = nvcc
 CUDAINC = -I$(CUDASDK)/common/inc -I$(CUDADIR)/include
 
-CHARMC=$(CDIR)/bin/charmc -cc $(CUDAC) -c++ $(CUDAC) $(OPTS) -nobs
-CCFLAGS = -DCUDA -DFP_TYPE_FLOAT  -g -DSHARED_NODES_ONLY_NEIGHBOR
+CHARMC  = $(CDIR)/bin/charmc $(OPTS) #-nobs -cc $(CUDAC) -c++ $(CUDAC)
+CCFLAGS = -DFP_TYPE_FLOAT -DSHARED_NODES_ONLY_NEIGHBOR #-DCUDA
 
 
 #Headers to be copied to include directory so application users can see them
 HEADERS= ParFUM_Iterators.h ParFUM_Iterators_CUDA.h ParFUM_Iterators_Types.h $(INTERNALHEADERS)
+
 #Headers generated from .ci files
 GENHEADERS= ParFUM_Iterators.decl.h 
+
 HEADDEP= $(GENHEADERS) $(HEADERS) $(INTERNALHEADERS)
 
-OBJS=ParFUM_Iterators.o ParFUM_Iterators_CPU.o ParFUM_Iterators_CUDA.o
+OBJS=ParFUM_Iterators.o ParFUM_Iterators_CPU.o #ParFUM_Iterators_CUDA.o
+
 LIB=libmoduleParFUM_Iterators
+
 LIBDIR=$(CDIR)/lib
 DEST=$(LIBDIR)/$(LIB).a
-INCS=-I. $(CUDAINC)
 
+INCS=-I. $(CUDAINC)
 
 all: $(DEST)
 
index d8adf58d367893f7a962bdf2a1cb1202cbf7a02c..ad554c5b41bab05f7c15128d019a4b1c7d99ef79 100644 (file)
@@ -45,9 +45,11 @@ int lib_FP_Type_Size()
 void mesh_set_device(MeshModel* m, MeshDevice d)
 {
   m->target_device = d;
+#if CUDA
   if(d == DeviceGPU){
     CkAssert(m->allocatedForCUDADevice);
   }
+#endif
 }
 
 
@@ -306,6 +308,7 @@ void meshModel_Create_Driver(MeshDevice target_device, int elem_attr_sz,
 
 
 
+#ifdef CUDA
 //  MeshDevice target_device
 void allocateModelForCUDADevice(MeshModel* model){
 
@@ -384,9 +387,6 @@ void allocateModelForCUDADevice(MeshModel* model){
 }
 
 
-
-
-
 //  Copy data from GPU and deallocate its memory
 void deallocateModelForCUDADevice(MeshModel* model){
 
@@ -445,6 +445,7 @@ void deallocateModelForCUDADevice(MeshModel* model){
     }
   }
 }
+#endif
 
 
 
index 5bfddd5fd943dd4527fca9e739a859daa011351b..aad04e9b82ef548a5e547be7f478c731cf205b52 100644 (file)
@@ -68,7 +68,9 @@ class MeshModel{
         MeshModel(){
             nodeIDHash = NULL;
             elemIDHash = NULL;
+#ifdef CUDA
            allocatedForCUDADevice = false;
+#endif
         }
 
 
@@ -103,8 +105,10 @@ class MeshModel{
 
 
 // 
+#ifdef CUDA
 void allocateModelForCUDADevice(MeshModel* model);
 void deallocateModelForCUDADevice(MeshModel* model);
+#endif
 
 
 
index 38a3a112c759959147072489e8c7286b9993c962..6f45b09b60978cbdbb601ef05b3037f6bffa03b5 100644 (file)
@@ -1,11 +1,12 @@
-CDIR=../../../..
-CHARMC=$(CDIR)/bin/charmc -cc $(CUDAC) -c++ $(CUDAC) $(OPTS) -nobs
+CDIR    = ../../../..
+
 CUDADIR = /usr/local/cuda
 CUDASDK = $(HOME)/TOPS-Tesla/NVIDIA_CUDA_SDK
-CUDAC = nvcc 
+CUDAC   = nvcc
 CUDAINC = -I$(CUDASDK)/common/inc -I$(CUDADIR)/include
-CCFLAGS = -DCUDA -DFP_TYPE_FLOAT  -O2 -DSHARED_NODES_ONLY_NEIGHBOR
-#CCFLAGS = -DCUDA -DFP_TYPE_DOUBLE -O2 -DSHARED_NODES_ONLY_NEIGHBOR
+
+CHARMC  = $(CDIR)/bin/charmc $(OPTS) #-nobs -cc $(CUDAC) -c++ $(CUDAC)
+CCFLAGS = -DFP_TYPE_FLOAT -DSHARED_NODES_ONLY_NEIGHBOR #-DCUDA
 
 #Headers to be copied to include directory so application users can see them
 HEADERS= ParFUM_TOPS.h ParFUM_TOPS_CUDA.h ParFUM_TOPS_Types.h $(INTERNALHEADERS)
@@ -15,7 +16,7 @@ GENHEADERS= ParFUM_TOPS.decl.h
 
 HEADDEP= $(GENHEADERS) $(HEADERS) $(INTERNALHEADERS)
 
-OBJS=ParFUM_TOPS.o ParFUM_TOPS_Iterators.o ParFUM_TOPS_CUDA.o
+OBJS=ParFUM_TOPS.o ParFUM_TOPS_Iterators.o #ParFUM_TOPS_CUDA.o
 
 LIB=libmoduleParFUM_TOPS
 
@@ -26,7 +27,6 @@ INCS=-I. $(CUDAINC)
 
 all: $(DEST)
 
-
 ParFUM_TOPS.decl.h: ParFUM_TOPS.ci
        $(CHARMC) ParFUM_TOPS.ci
 
index 364f9b6e17474e79b34d058bc78108c71b450841..487acce403a1031ef87042232bc37e88b54d5223 100644 (file)
@@ -68,7 +68,7 @@ headers: $(HEADDEP)
 
 
 MsaHashtable.o: MsaHashtable.C $(HEADDEP)
-       $(MPICC) -c MsaHashtable.C $(INCS)
+       $(MPICC) -DFOR_SUN_CC_ONLY -c MsaHashtable.C $(INCS)
 
 mesh_modify.o: mesh_modify.C $(HEADDEP)
        $(MPICC) -c mesh_modify.C $(INCS)
@@ -98,7 +98,7 @@ call_init.o: call_init.c $(HEADDEP)
        $(CHARMC) -c call_init.c $(INCS)
 
 parallel_part.o: parallel_part.C $(HEADDEP) MsaHashtable.h
-       $(MPICC) -c parallel_part.C $(INCS)
+       $(MPICC) -DFOR_SUN_CC_ONLY -c parallel_part.C $(INCS)
 
 mesh_adjacency.o: mesh_adjacency.C $(HEADDEP)
        $(MPICC) -c mesh_adjacency.C $(INCS)
index e41a11519d999930a08570e1a3292630b2b42bc0..c045deb779f655891e93f5cb5722bc3d9e408d75 100644 (file)
@@ -2053,6 +2053,9 @@ class FEM_ElemAdj_Layer : public CkNoncopyable {
 
 //#define PARALLEL_DEBUG
 
+#ifdef DEBUG
+#undef DEBUG
+#endif
 #ifdef PARALLEL_DEBUG
 #define DEBUG(x) x
 #else
index 03d9f420a69558c180d7298fb703008007344aba..a9d2b0537de65ae30f1dc65f7bd0a8968dc79188 100644 (file)
@@ -166,12 +166,14 @@ public:
         return msa->get2(x);
     }
 
+#ifndef FOR_SUN_CC_ONLY
     // 2D Array access
     inline const ENTRY& get(int x, int y)
     {
         checkValid();
         return msa->get(x, y);
     }
+#endif
     inline const ENTRY& operator()(int x, int y) { return get(x, y); }
     inline const ENTRY& get2(int x, int y)
     {
@@ -179,12 +181,14 @@ public:
         return msa->get2(x, y);
     }
 
+#ifndef FOR_SUN_CC_ONLY
     // 3D Array Access
     inline const ENTRY& get(int x, int y, int z)
     {
         checkValid();
         return msa->get(x, y, z);
     }
+#endif
     inline const ENTRY& operator()(int x, int y, int z) { return get(x, y, z); }
     inline const ENTRY& get2(int x, int y, int z)
     {
@@ -317,24 +321,29 @@ public:
     inline Accumulable<MSA> operator() (int x)
     { return accumulate(x); }
 
+#ifndef FOR_SUN_CC_ONLY
     // 2D Array Access
     inline Accumulable<MSA> accumulate(int x, int y)
     {
         checkValid();
         return Accumulable<MSA>(msa->accumulate(x,y));
     }
+#endif
     inline Accumulable<MSA> operator() (int x, int y)
     { return accumulate(x,y); }
 
+#ifndef FOR_SUN_CC_ONLY
     // 3D Array Access
     inline Accumulable<MSA> accumulate(int x, int y, int z)
     {
         checkValid();
         return Accumulable<MSA>(msa->accumulate(x,y,z));
     }
+#endif
     inline Accumulable<MSA> operator() (int x, int y, int z)
     { return accumulate(x,y,z); }
 
+#ifndef FOR_SUN_CC_ONLY
     void accumulate(int x1, int y1, int z1, int x2, int y2, int z2, const ENTRY *buf)
     {
         checkValid();
@@ -357,6 +366,7 @@ public:
                 for (int iz = z1; iz <= z2; ++iz)
                     msa->accumulate(ix, iy, iz, buf[i++]);
     }
+#endif
 };
 
 
index 8ca8ad0f951f8dfe70efc91fa9bf26eb8a080dad..686b5fced53ce51a8c010fe60cefca1d9efdb623 100644 (file)
@@ -35,6 +35,9 @@ class rep
   unsigned short int prand48_seed[3];
   /// Flag indicating this object uses anti-methods rather than checkpoints
   int anti_methods;
+  /// Starting GVT of the simulation
+  /** Initialize to -1, which is the "unset" value */
+  POSE_TimeType simulationStartGVT;
 #ifdef MEM_TEMPORAL
   TimePool *localTimePool;
 #endif
@@ -42,6 +45,7 @@ class rep
   rep() { 
     ovt = 0; ort = 0.0; parent = NULL; myStrat = NULL; 
     anti_methods = 0;
+    simulationStartGVT = (POSE_TimeType)-1;
   #ifndef SEQUENTIAL_POSE
   #ifdef POSE_COMM_ON    
     POSE_Objects = POSE_Objects_RO;
@@ -55,10 +59,11 @@ class rep
   /// Initializing Constructor
   rep(POSE_TimeType init_ovt) { 
     ovt = init_ovt; ort = 0.0; anti_methods = 0;
-      }
+    simulationStartGVT = (POSE_TimeType)-1;
+  }
   /// Destructor
   virtual ~rep() {
-     }
+  }
   /// Initializer called from poser wrapper constructor
   void init(eventMsg *m);
   /// Return the OVT
@@ -83,6 +88,11 @@ class rep
   }
   /// Timestamps event message, sets priority, and records in spawned list
   virtual void registerTimestamp(int idx, eventMsg *m, POSE_TimeType offset);
+  /// Set simulationStartGVT
+  void setSimulationStartGVT(POSE_TimeType startGVT) {
+    CkAssert(startGVT >= 0);
+    simulationStartGVT = startGVT;
+  }
   /// Assignment operator
   /** Derived classes must provide assignment */
   inline virtual rep& operator=(const rep& obj) { 
@@ -94,6 +104,7 @@ class rep
     prand48_seed[0]=obj.prand48_seed[0];
     prand48_seed[1]=obj.prand48_seed[1];
     prand48_seed[2]=obj.prand48_seed[2];
+    simulationStartGVT = obj.simulationStartGVT;
     return *this;
   }
   /// Dump all data fields
@@ -105,7 +116,7 @@ class rep
   /// Pack/unpack/sizing operator
   /** Derived classes must provide pup */
   virtual void pup(PUP::er &p) { 
-    p(ovt); p(ort); p(myHandle); p(anti_methods); p(prand_seed); p(prand48_seed,3);
+    p(ovt); p(ort); p(myHandle); p(anti_methods); p(prand_seed); p(prand48_seed,3); p(simulationStartGVT);
   }
 #ifdef SEQUENTIAL_POSE
   inline void checkpoint(rep *) { }
index 273edc2d2294e307a3fcbae4292e1beb5138f9db..b4206574958045bcac5f22f4b108a96024b2881e 100644 (file)
@@ -28,5 +28,6 @@ module sim {
     entry void SeqBeginCheckpoint();
     entry void SeqResumeAfterCheckpoint();
     entry void invokeStopEvent();
+    entry void setSimulationStartGVT(POSE_TimeType);
   };
 };
index 0be574f22fa4eccdc5ab6e8d375c29297a311d28..e0c11a1f08745be485dd8ce1c1aa84e16716dbed 100644 (file)
@@ -221,7 +221,7 @@ class sim : public CBase_sim {
   int *srVector;    
   /// Most recent GVT estimate
   POSE_TimeType lastGVT;
-  /// Relative start time, start time, end time and current time
+  /// Relative start time, end time, and current time
   /** Used to calculate degree of parallelism */
   double st, et, ct;
 #ifndef CMK_OPTIMIZE
@@ -275,6 +275,10 @@ class sim : public CBase_sim {
   void SeqResumeAfterCheckpoint();
   /// Implement this for posers that will need to execute events when POSE reaches quiescence
   void invokeStopEvent() {}
+  /// Set simulationStartGVT in the rep
+  void setSimulationStartGVT(POSE_TimeType startGVT) {
+    objID->setSimulationStartGVT(startGVT);
+  }
   /// Return this poser's unique index on PVT branch
   inline int PVTindex() { return myPVTidx; }
   /// Test active flag
index 5ef256215433dca88d3f4c98834db7671ffe067d..6b149cb9907afa74614aa46bce63054c093c2a10 100755 (executable)
@@ -1,11 +1,11 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.67.
+# Generated by GNU Autoconf 2.65.
 #
 #
 # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
-# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software
-# Foundation, Inc.
+# 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation,
+# Inc.
 #
 #
 # This configure script is free software; the Free Software Foundation
@@ -315,7 +315,7 @@ $as_echo X"$as_dir" |
       test -d "$as_dir" && break
     done
     test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+  } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"
 
 
 } # as_fn_mkdir_p
@@ -355,19 +355,19 @@ else
 fi # as_fn_arith
 
 
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
+# as_fn_error ERROR [LINENO LOG_FD]
+# ---------------------------------
 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
+# script with status $?, using 1 if that was 0.
 as_fn_error ()
 {
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  as_status=$?; test $as_status -eq 0 && as_status=1
+  if test "$3"; then
+    as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
   fi
-  $as_echo "$as_me: error: $2" >&2
+  $as_echo "$as_me: error: $1" >&2
   as_fn_exit $as_status
 } # as_fn_error
 
@@ -529,7 +529,7 @@ test -n "$DJDIR" || exec 7<&0 </dev/null
 exec 6>&1
 
 # Name of the host.
-# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 # so uname gets run too.
 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 
@@ -671,9 +671,8 @@ do
   fi
 
   case $ac_option in
-  *=?*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
-  *=)   ac_optarg= ;;
-  *)    ac_optarg=yes ;;
+  *=*) ac_optarg=`expr "X$ac_option" : '[^=]*=\(.*\)'` ;;
+  *)   ac_optarg=yes ;;
   esac
 
   # Accept the important Cygnus configure options, so we can diagnose typos.
@@ -718,7 +717,7 @@ do
     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
     # Reject names that are not valid shell variable names.
     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
+      as_fn_error "invalid feature name: $ac_useropt"
     ac_useropt_orig=$ac_useropt
     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
     case $ac_user_opts in
@@ -744,7 +743,7 @@ do
     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
     # Reject names that are not valid shell variable names.
     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid feature name: $ac_useropt"
+      as_fn_error "invalid feature name: $ac_useropt"
     ac_useropt_orig=$ac_useropt
     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
     case $ac_user_opts in
@@ -948,7 +947,7 @@ do
     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
     # Reject names that are not valid shell variable names.
     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
+      as_fn_error "invalid package name: $ac_useropt"
     ac_useropt_orig=$ac_useropt
     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
     case $ac_user_opts in
@@ -964,7 +963,7 @@ do
     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
     # Reject names that are not valid shell variable names.
     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
-      as_fn_error $? "invalid package name: $ac_useropt"
+      as_fn_error "invalid package name: $ac_useropt"
     ac_useropt_orig=$ac_useropt
     ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
     case $ac_user_opts in
@@ -994,8 +993,8 @@ do
   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
     x_libraries=$ac_optarg ;;
 
-  -*) as_fn_error $? "unrecognized option: \`$ac_option'
-Try \`$0 --help' for more information"
+  -*) as_fn_error "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information."
     ;;
 
   *=*)
@@ -1003,7 +1002,7 @@ Try \`$0 --help' for more information"
     # Reject names that are not valid shell variable names.
     case $ac_envvar in #(
       '' | [0-9]* | *[!_$as_cr_alnum]* )
-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+      as_fn_error "invalid variable name: \`$ac_envvar'" ;;
     esac
     eval $ac_envvar=\$ac_optarg
     export $ac_envvar ;;
@@ -1021,13 +1020,13 @@ done
 
 if test -n "$ac_prev"; then
   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
-  as_fn_error $? "missing argument to $ac_option"
+  as_fn_error "missing argument to $ac_option"
 fi
 
 if test -n "$ac_unrecognized_opts"; then
   case $enable_option_checking in
     no) ;;
-    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    fatal) as_fn_error "unrecognized options: $ac_unrecognized_opts" ;;
     *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
   esac
 fi
@@ -1050,7 +1049,7 @@ do
     [\\/$]* | ?:[\\/]* )  continue;;
     NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
   esac
-  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+  as_fn_error "expected an absolute directory name for --$ac_var: $ac_val"
 done
 
 # There might be people who depend on the old broken behavior: `$host'
@@ -1064,8 +1063,8 @@ target=$target_alias
 if test "x$host_alias" != x; then
   if test "x$build_alias" = x; then
     cross_compiling=maybe
-    $as_echo "$as_me: WARNING: if you wanted to set the --build type, don't use --host.
-    If a cross compiler is detected then cross compile mode will be used" >&2
+    $as_echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
+    If a cross compiler is detected then cross compile mode will be used." >&2
   elif test "x$build_alias" != "x$host_alias"; then
     cross_compiling=yes
   fi
@@ -1080,9 +1079,9 @@ test "$silent" = yes && exec 6>/dev/null
 ac_pwd=`pwd` && test -n "$ac_pwd" &&
 ac_ls_di=`ls -di .` &&
 ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
-  as_fn_error $? "working directory cannot be determined"
+  as_fn_error "working directory cannot be determined"
 test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
-  as_fn_error $? "pwd does not report name of working directory"
+  as_fn_error "pwd does not report name of working directory"
 
 
 # Find the source files, if location was not specified.
@@ -1121,11 +1120,11 @@ else
 fi
 if test ! -r "$srcdir/$ac_unique_file"; then
   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
-  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+  as_fn_error "cannot find sources ($ac_unique_file) in $srcdir"
 fi
 ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
 ac_abs_confdir=`(
-       cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+       cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error "$ac_msg"
        pwd)`
 # When building in place, set srcdir=.
 if test "$ac_abs_confdir" = "$ac_pwd"; then
@@ -1165,7 +1164,7 @@ Configuration:
       --help=short        display options specific to this package
       --help=recursive    display the short help of all the included packages
   -V, --version           display version information and exit
-  -q, --quiet, --silent   do not print \`checking ...' messages
+  -q, --quiet, --silent   do not print \`checking...' messages
       --cache-file=FILE   cache test results in FILE [disabled]
   -C, --config-cache      alias for \`--cache-file=config.cache'
   -n, --no-create         do not create output files
@@ -1293,9 +1292,9 @@ test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
 configure
-generated by GNU Autoconf 2.67
+generated by GNU Autoconf 2.65
 
-Copyright (C) 2010 Free Software Foundation, Inc.
+Copyright (C) 2009 Free Software Foundation, Inc.
 This configure script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it.
 _ACEOF
@@ -1310,7 +1309,7 @@ This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
 It was created by $as_me, which was
-generated by GNU Autoconf 2.67.  Invocation command line was
+generated by GNU Autoconf 2.65.  Invocation command line was
 
   $ $0 $@
 
@@ -1420,9 +1419,11 @@ trap 'exit_status=$?
   {
     echo
 
-    $as_echo "## ---------------- ##
+    cat <<\_ASBOX
+## ---------------- ##
 ## Cache variables. ##
-## ---------------- ##"
+## ---------------- ##
+_ASBOX
     echo
     # The following way of writing the cache mishandles newlines in values,
 (
@@ -1456,9 +1457,11 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
 )
     echo
 
-    $as_echo "## ----------------- ##
+    cat <<\_ASBOX
+## ----------------- ##
 ## Output variables. ##
-## ----------------- ##"
+## ----------------- ##
+_ASBOX
     echo
     for ac_var in $ac_subst_vars
     do
@@ -1471,9 +1474,11 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
     echo
 
     if test -n "$ac_subst_files"; then
-      $as_echo "## ------------------- ##
+      cat <<\_ASBOX
+## ------------------- ##
 ## File substitutions. ##
-## ------------------- ##"
+## ------------------- ##
+_ASBOX
       echo
       for ac_var in $ac_subst_files
       do
@@ -1487,9 +1492,11 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
     fi
 
     if test -s confdefs.h; then
-      $as_echo "## ----------- ##
+      cat <<\_ASBOX
+## ----------- ##
 ## confdefs.h. ##
-## ----------- ##"
+## ----------- ##
+_ASBOX
       echo
       cat confdefs.h
       echo
@@ -1544,12 +1551,7 @@ _ACEOF
 ac_site_file1=NONE
 ac_site_file2=NONE
 if test -n "$CONFIG_SITE"; then
-  # We do not want a PATH search for config.site.
-  case $CONFIG_SITE in #((
-    -*)  ac_site_file1=./$CONFIG_SITE;;
-    */*) ac_site_file1=$CONFIG_SITE;;
-    *)   ac_site_file1=./$CONFIG_SITE;;
-  esac
+  ac_site_file1=$CONFIG_SITE
 elif test "x$prefix" != xNONE; then
   ac_site_file1=$prefix/share/config.site
   ac_site_file2=$prefix/etc/config.site
@@ -1564,11 +1566,7 @@ do
     { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
 $as_echo "$as_me: loading site script $ac_site_file" >&6;}
     sed 's/^/| /' "$ac_site_file" >&5
-    . "$ac_site_file" \
-      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "failed to load site script $ac_site_file
-See \`config.log' for more details" "$LINENO" 5 ; }
+    . "$ac_site_file"
   fi
 done
 
@@ -1644,7 +1642,7 @@ if $ac_cache_corrupted; then
 $as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
   { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
 $as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
-  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+  as_fn_error "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
 fi
 ## -------------------- ##
 ## Main body of script. ##
@@ -2124,6 +2122,15 @@ then
        test_finish 1
 fi
 
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking \"Native C++ compiler as\"" >&5
+$as_echo_n "checking \"Native C++ compiler as\"... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: \"$CMK_NATIVE_CXX\"" >&5
+$as_echo "\"$CMK_NATIVE_CXX\"" >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking \"Sequential C++ compiler as\"" >&5
+$as_echo_n "checking \"Sequential C++ compiler as\"... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: \"$CMK_SEQ_CXX\"" >&5
+$as_echo "\"$CMK_SEQ_CXX\"" >&6; }
+
 if test "$base_version" = "net-linux"
 then
   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
@@ -3880,7 +3887,6 @@ DEFS=-DHAVE_CONFIG_H
 
 ac_libobjs=
 ac_ltlibobjs=
-U=
 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
   # 1. Remove the extension, and $U if already installed.
   ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
@@ -4042,19 +4048,19 @@ export LANGUAGE
 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
 
-# as_fn_error STATUS ERROR [LINENO LOG_FD]
-# ----------------------------------------
+# as_fn_error ERROR [LINENO LOG_FD]
+# ---------------------------------
 # Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
 # provided, also output the error to LOG_FD, referencing LINENO. Then exit the
-# script with STATUS, using 1 if that was 0.
+# script with status $?, using 1 if that was 0.
 as_fn_error ()
 {
-  as_status=$1; test $as_status -eq 0 && as_status=1
-  if test "$4"; then
-    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  as_status=$?; test $as_status -eq 0 && as_status=1
+  if test "$3"; then
+    as_lineno=${as_lineno-"$2"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $1" >&$3
   fi
-  $as_echo "$as_me: error: $2" >&2
+  $as_echo "$as_me: error: $1" >&2
   as_fn_exit $as_status
 } # as_fn_error
 
@@ -4250,7 +4256,7 @@ $as_echo X"$as_dir" |
       test -d "$as_dir" && break
     done
     test -z "$as_dirs" || eval "mkdir $as_dirs"
-  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+  } || test -d "$as_dir" || as_fn_error "cannot create directory $as_dir"
 
 
 } # as_fn_mkdir_p
@@ -4304,7 +4310,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # values after options handling.
 ac_log="
 This file was extended by $as_me, which was
-generated by GNU Autoconf 2.67.  Invocation command line was
+generated by GNU Autoconf 2.65.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
   CONFIG_HEADERS  = $CONFIG_HEADERS
@@ -4370,10 +4376,10 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
 config.status
-configured by $0, generated by GNU Autoconf 2.67,
+configured by $0, generated by GNU Autoconf 2.65,
   with options \\"\$ac_cs_config\\"
 
-Copyright (C) 2010 Free Software Foundation, Inc.
+Copyright (C) 2009 Free Software Foundation, Inc.
 This config.status script is free software; the Free Software Foundation
 gives unlimited permission to copy, distribute and modify it."
 
@@ -4388,16 +4394,11 @@ ac_need_defaults=:
 while test $# != 0
 do
   case $1 in
-  --*=?*)
+  --*=*)
     ac_option=`expr "X$1" : 'X\([^=]*\)='`
     ac_optarg=`expr "X$1" : 'X[^=]*=\(.*\)'`
     ac_shift=:
     ;;
-  --*=)
-    ac_option=`expr "X$1" : 'X\([^=]*\)='`
-    ac_optarg=
-    ac_shift=:
-    ;;
   *)
     ac_option=$1
     ac_optarg=$2
@@ -4419,7 +4420,6 @@ do
     $ac_shift
     case $ac_optarg in
     *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-    '') as_fn_error $? "missing file argument" ;;
     esac
     as_fn_append CONFIG_FILES " '$ac_optarg'"
     ac_need_defaults=false;;
@@ -4432,7 +4432,7 @@ do
     ac_need_defaults=false;;
   --he | --h)
     # Conflict between --help and --header
-    as_fn_error $? "ambiguous option: \`$1'
+    as_fn_error "ambiguous option: \`$1'
 Try \`$0 --help' for more information.";;
   --help | --hel | -h )
     $as_echo "$ac_cs_usage"; exit ;;
@@ -4441,7 +4441,7 @@ Try \`$0 --help' for more information.";;
     ac_cs_silent=: ;;
 
   # This is an error.
-  -*) as_fn_error $? "unrecognized option: \`$1'
+  -*) as_fn_error "unrecognized option: \`$1'
 Try \`$0 --help' for more information." ;;
 
   *) as_fn_append ac_config_targets " $1"
@@ -4495,7 +4495,7 @@ do
     "libs/ck-libs/ampi/ampirun") CONFIG_FILES="$CONFIG_FILES libs/ck-libs/ampi/ampirun" ;;
     "default") CONFIG_COMMANDS="$CONFIG_COMMANDS default" ;;
 
-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5 ;;
+  *) as_fn_error "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
   esac
 done
 
@@ -4533,7 +4533,7 @@ $debug ||
 {
   tmp=./conf$$-$RANDOM
   (umask 077 && mkdir "$tmp")
-} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+} || as_fn_error "cannot create a temporary directory in ." "$LINENO" 5
 
 # Set up the scripts for CONFIG_FILES section.
 # No need to generate them if there are no CONFIG_FILES.
@@ -4550,7 +4550,7 @@ if test "x$ac_cr" = x; then
 fi
 ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
 if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
-  ac_cs_awk_cr='\\r'
+  ac_cs_awk_cr='\r'
 else
   ac_cs_awk_cr=$ac_cr
 fi
@@ -4564,18 +4564,18 @@ _ACEOF
   echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
   echo "_ACEOF"
 } >conf$$subs.sh ||
-  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
-ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+  as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '$'`
 ac_delim='%!_!# '
 for ac_last_try in false false false false false :; do
   . ./conf$$subs.sh ||
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+    as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
 
   ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
   if test $ac_delim_n = $ac_delim_num; then
     break
   elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+    as_fn_error "could not make $CONFIG_STATUS" "$LINENO" 5
   else
     ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
   fi
@@ -4664,28 +4664,20 @@ if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
 else
   cat
 fi < "$tmp/subs1.awk" > "$tmp/subs.awk" \
-  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+  || as_fn_error "could not setup config files machinery" "$LINENO" 5
 _ACEOF
 
-# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
-# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# VPATH may cause trouble with some makes, so we remove $(srcdir),
+# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
 # trailing colons and then remove the whole line if VPATH becomes empty
 # (actually we leave an empty line to preserve line numbers).
 if test "x$srcdir" = x.; then
-  ac_vpsub='/^[         ]*VPATH[        ]*=[    ]*/{
-h
-s///
-s/^/:/
-s/[     ]*$/:/
-s/:\$(srcdir):/:/g
-s/:\${srcdir}:/:/g
-s/:@srcdir@:/:/g
-s/^:*//
+  ac_vpsub='/^[         ]*VPATH[        ]*=/{
+s/:*\$(srcdir):*/:/
+s/:*\${srcdir}:*/:/
+s/:*@srcdir@:*/:/
+s/^\([^=]*=[    ]*\):*/\1/
 s/:*$//
-x
-s/\(=[  ]*\).*/\1/
-G
-s/\n//
 s/^[^=]*=[      ]*$//
 }'
 fi
@@ -4713,7 +4705,7 @@ for ac_last_try in false false :; do
   if test -z "$ac_t"; then
     break
   elif $ac_last_try; then
-    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
+    as_fn_error "could not make $CONFIG_HEADERS" "$LINENO" 5
   else
     ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
   fi
@@ -4798,7 +4790,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 _ACAWK
 _ACEOF
 cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
-  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
+  as_fn_error "could not setup config headers machinery" "$LINENO" 5
 fi # test -n "$CONFIG_HEADERS"
 
 
@@ -4811,7 +4803,7 @@ do
   esac
   case $ac_mode$ac_tag in
   :[FHL]*:*);;
-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5 ;;
+  :L* | :C*:*) as_fn_error "invalid tag \`$ac_tag'" "$LINENO" 5;;
   :[FH]-) ac_tag=-:-;;
   :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
   esac
@@ -4839,7 +4831,7 @@ do
           [\\/$]*) false;;
           *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
           esac ||
-          as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5 ;;
+          as_fn_error "cannot find input file: \`$ac_f'" "$LINENO" 5;;
       esac
       case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
       as_fn_append ac_file_inputs " '$ac_f'"
@@ -4866,7 +4858,7 @@ $as_echo "$as_me: creating $ac_file" >&6;}
 
     case $ac_tag in
     *:-:* | *:-) cat >"$tmp/stdin" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5  ;;
+      || as_fn_error "could not create $ac_file" "$LINENO" 5 ;;
     esac
     ;;
   esac
@@ -4992,22 +4984,22 @@ s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
 $ac_datarootdir_hack
 "
 eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$tmp/subs.awk" >$tmp/out \
-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+  || as_fn_error "could not create $ac_file" "$LINENO" 5
 
 test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
   { ac_out=`sed -n '/\${datarootdir}/p' "$tmp/out"`; test -n "$ac_out"; } &&
   { ac_out=`sed -n '/^[         ]*datarootdir[  ]*:*=/p' "$tmp/out"`; test -z "$ac_out"; } &&
   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&5
+which seems to be undefined.  Please make sure it is defined." >&5
 $as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-which seems to be undefined.  Please make sure it is defined" >&2;}
+which seems to be undefined.  Please make sure it is defined." >&2;}
 
   rm -f "$tmp/stdin"
   case $ac_file in
   -) cat "$tmp/out" && rm -f "$tmp/out";;
   *) rm -f "$ac_file" && mv "$tmp/out" "$ac_file";;
   esac \
-  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+  || as_fn_error "could not create $ac_file" "$LINENO" 5
  ;;
   :H)
   #
@@ -5018,19 +5010,19 @@ which seems to be undefined.  Please make sure it is defined" >&2;}
       $as_echo "/* $configure_input  */" \
       && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs"
     } >"$tmp/config.h" \
-      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+      || as_fn_error "could not create $ac_file" "$LINENO" 5
     if diff "$ac_file" "$tmp/config.h" >/dev/null 2>&1; then
       { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
 $as_echo "$as_me: $ac_file is unchanged" >&6;}
     else
       rm -f "$ac_file"
       mv "$tmp/config.h" "$ac_file" \
-       || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+       || as_fn_error "could not create $ac_file" "$LINENO" 5
     fi
   else
     $as_echo "/* $configure_input  */" \
       && eval '$AWK -f "$tmp/defines.awk"' "$ac_file_inputs" \
-      || as_fn_error $? "could not create -" "$LINENO" 5
+      || as_fn_error "could not create -" "$LINENO" 5
   fi
  ;;
 
@@ -5053,7 +5045,7 @@ _ACEOF
 ac_clean_files=$ac_clean_files_save
 
 test $ac_write_fail = 0 ||
-  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+  as_fn_error "write failure creating $CONFIG_STATUS" "$LINENO" 5
 
 
 # configure is writing to config.log, and then calls config.status.
@@ -5074,7 +5066,7 @@ if test "$no_create" != yes; then
   exec 5>>config.log
   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
   # would make configure fail if this is the last instruction.
-  $ac_cs_success || as_fn_exit 1
+  $ac_cs_success || as_fn_exit $?
 fi
 if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
index 84999ed1e00307506a51ff32c5be9e6a16219478..0c0616fc648d17ea820d35417d4b2a435dd8cb53 100644 (file)
@@ -379,6 +379,11 @@ then
        test_finish 1
 fi
 
+AC_MSG_CHECKING("Native C++ compiler as")
+AC_MSG_RESULT("$CMK_NATIVE_CXX")
+AC_MSG_CHECKING("Sequential C++ compiler as")
+AC_MSG_RESULT("$CMK_SEQ_CXX")
+
 if test "$base_version" = "net-linux" 
 then
   test_link "whether linker accept --allow-multiple-definition" "ok" "no" "-Wl,--allow-multiple-definition"
index cf9352ee59bf7e706827789f6f901369a3874615..1d8916d9b03c2017f321e83eb78a154667c681f5 100644 (file)
@@ -77,7 +77,12 @@ then
   QT=`echo $CMK_QT | sed -e 's/64$//'`
   if test $QT = $CMK_QT
   then
-    CMK_QT="${CMK_QT}64"
+    if echo $CMK_QT | grep '-' > /dev/null 2> /dev/null
+    then
+      CMK_QT=`echo $CMK_QT | sed -e 's/-/64-/'`
+    else
+      CMK_QT="${CMK_QT}64"
+    fi
   fi
 fi
 
index 528de4ac47ae03ec662c1d24079c0cb4badc7dc8..8909b006b33ed43a0ebc4fa60db733d17aafca07 100644 (file)
@@ -7,6 +7,7 @@
  *  can be called from C++ files
  */
 
+#include <stdlib.h>
 #include "converse.h"
 
 #if CMK_CRAYXT
@@ -38,7 +39,7 @@ int getXTNodeID(int mpirank, int nummpiranks) {
   /* free(nidpid); */
 
 #else  /* if it is a XT4/5 */
-  PMI_Portals_get_nid(mpirank, &nid);
+  PMI_Get_nid(mpirank, &nid);
 #endif
 
   return nid;
@@ -125,7 +126,7 @@ void pidtonid(int numpes) {
       nid2pid[i][l] = -1;
 
   for (i=0; i<numpes; i++) {
-    PMI_Portals_get_nid(i, &nid);
+    PMI_Get_nid(i, &nid);
     pid2nid[i] = nid;
 
     l = 0;
index 31c1e51d463ae1d4a8e474e1cf9f974437a85056..3fa94653b7d6dfa1771d8ea5fef1a650f8062b8f 100644 (file)
@@ -225,6 +225,7 @@ int TopoManager::coordinatesToRank(int x, int y, int z) {
   return bgptm.coordinatesToRank(x, y, z);
 #elif XT3_TOPOLOGY || XT4_TOPOLOGY || XT5_TOPOLOGY
   CmiAbort("This function should not be called on Cray XT machines\n");
+  return -1;
 #else
   if(dimY > 1)
     return x + y*dimX + z*dimX*dimY;
index 96250364f1d77164f6fec9bc6078e724f589be00..e7874062a7ca17b756eab54b78ba0554d60ef62d 100644 (file)
@@ -154,7 +154,8 @@ inline void operator|(PUP::er &p,typename std::list<T> &v)
 
 template <class V,class T,class Cmp> 
 inline void operator|(PUP::er &p,typename std::map<V,T,Cmp> &m)
-  { PUP_stl_map<std::map<V,T,Cmp>,std::pair<const V,T> >(p,m); }
+  //{ PUP_stl_map<std::map<V,T,Cmp>,std::pair<const V,T> >(p,m); }    // 'const' confuses old version of a SUN CC compiler
+  { PUP_stl_map<std::map<V,T,Cmp>,std::pair<V,T> >(p,m); }
 template <class V,class T,class Cmp> 
 inline void operator|(PUP::er &p,typename std::multimap<V,T,Cmp> &m)
   { PUP_stl_map<std::multimap<V,T,Cmp>,std::pair<const V,T> >(p,m); }
index 062b02436d144a2975c6f62ffa382c91084425bf..8144dd0e64aca7478c1ed9b0564508b88cb2e3e1 100644 (file)
@@ -1,5 +1,5 @@
-#ifndef __SIMD_H__
-#define __SIMD_H__
+#ifndef __SIMDIA_H__
+#define __SIMDIA_H__
 
 
 #if defined(__SSE2__)
 #endif
 
 
+
 /* Flags to force architecture specific SIMD instructions off */
-#define FORCE_NO_SSE       (0)
-#define FORCE_NO_ALTIVEC   (0)
-#define FORCE_NO_SPE_SIMD  (0)
+#define SIMDIA_FORCE_NO_SSE       (0)
+#define SIMDIA_FORCE_NO_ALTIVEC   (0)
+#define SIMDIA_FORCE_NO_SPE_SIMD  (0)
 
 
 /***** Math Constants *****/
-#define __SIMD__CONSTANT_PI      (3.141592653589793)
-#define __SIMD__CONSTANT_E       (2.718281828459045)
-#define __SIMD__CONSTANT_SQRT_2  (1.414213562373095)
-/* TODO | FIXME - Added intrinsics below for loading/creating vectors with these values */
+#define SIMDIA_CONSTANT_PI      (3.141592653589793)
+#define SIMDIA_CONSTANT_E       (2.718281828459045)
+#define SIMDIA_CONSTANT_SQRT_2  (1.414213562373095)
 
 
 /* TODO | FIXME - Find platform independent way of ensuring alignment
  */
  
 /***** Data Types *****/
-/*
- * typedef struct __vec_16_c  {           char v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15; } __vec16c;
- * typedef struct __vec_16_uc {  unsigned char v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15; } __vec16uc;
- * typedef struct __vec_8_s  {          short v0, v1, v2, v3, v4, v5, v6, v7; } __vec8s;
- * typedef struct __vec_8_us { unsigned short v0, v1, v2, v3, v4, v5, v6, v7; } __vec8us;
- * typedef struct __vec_4_ui {   unsigned int v0, v1, v2, v3; } __vec4ui;
- */
-
-
-typedef struct __vec_i  {    int v0, v1, v2, v3; }  __veci;
-typedef struct __vec_f  {  float v0, v1, v2, v3; }  __vecf;
-typedef struct __vec_lf { double v0, v1;         } __veclf;
+/* NOTE (DMK): Since this is the generic implementation, arbitrarily choosing 128 byte "vector" size. */
+typedef struct __simdia_vec_i  {    int v0, v1, v2, v3; }  __simdia_veci;
+typedef struct __simdia_vec_f  {  float v0, v1, v2, v3; }  __simdia_vecf;
+typedef struct __simdia_vec_lf { double v0, v1;         } __simdia_veclf;
 
 
 /***** Insert *****/
-inline  __veci  __vinserti( __veci v, const    int s, const int i) {  __veci r = v;    int* rPtr = (   int*)(&r); rPtr[i] = s; return r; }
-inline  __vecf  __vinsertf( __vecf v, const  float s, const int i) {  __vecf r = v;  float* rPtr = ( float*)(&r); rPtr[i] = s; return r; }
-inline __veclf __vinsertlf(__veclf v, const double s, const int i) { __veclf r = v; double* rPtr = (double*)(&r); rPtr[i] = s; return r; }
+inline  __simdia_veci  __simdia_vinserti( __simdia_veci v, const    int s, const int i) {  __simdia_veci r = v;    int* rPtr = (   int*)(&r); rPtr[i] = s; return r; }
+inline  __simdia_vecf  __simdia_vinsertf( __simdia_vecf v, const  float s, const int i) {  __simdia_vecf r = v;  float* rPtr = ( float*)(&r); rPtr[i] = s; return r; }
+inline __simdia_veclf __simdia_vinsertlf(__simdia_veclf v, const double s, const int i) { __simdia_veclf r = v; double* rPtr = (double*)(&r); rPtr[i] = s; return r; }
 
 /***** Extract *****/
-inline    int  __vextracti( __veci v, const int i) {    int* vPtr = (   int*)(&v); return vPtr[i]; }
-inline  float  __vextractf( __vecf v, const int i) {  float* vPtr = ( float*)(&v); return vPtr[i]; }
-inline double __vextractlf(__veclf v, const int i) { double* vPtr = (double*)(&v); return vPtr[i]; }
+inline    int  __simdia_vextracti( __simdia_veci v, const int i) {    int* vPtr = (   int*)(&v); return vPtr[i]; }
+inline  float  __simdia_vextractf( __simdia_vecf v, const int i) {  float* vPtr = ( float*)(&v); return vPtr[i]; }
+inline double __simdia_vextractlf(__simdia_veclf v, const int i) { double* vPtr = (double*)(&v); return vPtr[i]; }
 
 /***** Set *****/
-inline  __veci  __vseti(const    int a) {  __veci r; r.v0 = r.v1 = r.v2 = r.v3 = a; return r; }
-inline  __vecf  __vsetf(const  float a) {  __vecf r; r.v0 = r.v1 = r.v2 = r.v3 = a; return r; }
-inline __veclf __vsetlf(const double a) { __veclf r; r.v0 = r.v1 =               a; return r; }
+inline  __simdia_veci  __simdia_vseti(const    int a) {  __simdia_veci r; r.v0 = r.v1 = r.v2 = r.v3 = a; return r; }
+inline  __simdia_vecf  __simdia_vsetf(const  float a) {  __simdia_vecf r; r.v0 = r.v1 = r.v2 = r.v3 = a; return r; }
+inline __simdia_veclf __simdia_vsetlf(const double a) { __simdia_veclf r; r.v0 = r.v1 =               a; return r; }
 
 /* NOTE: Would it be better to generate the constants instead of read them from memory in the generic version? */
 
 /***** Constant Zero *****/
-const  __veci  __const_vzeroi = {   0 ,   0 ,   0 ,   0  };
-const  __vecf  __const_vzerof = { 0.0f, 0.0f, 0.0f, 0.0f };
-const __veclf __const_vzerolf = { 0.0 , 0.0              };
+const  __simdia_veci  __simdia_const_vzeroi = {   0 ,   0 ,   0 ,   0  };
+const  __simdia_vecf  __simdia_const_vzerof = { 0.0f, 0.0f, 0.0f, 0.0f };
+const __simdia_veclf __simdia_const_vzerolf = { 0.0 , 0.0              };
 
 /***** Constant One *****/
-const  __veci  __const_vonei = {   1 ,   1 ,   1 ,   1  };
-const  __vecf  __const_vonef = { 1.0f, 1.0f, 1.0f, 1.0f };
-const __veclf __const_vonelf = { 1.0 , 1.0              };
+const  __simdia_veci  __simdia_const_vonei = {   1 ,   1 ,   1 ,   1  };
+const  __simdia_vecf  __simdia_const_vonef = { 1.0f, 1.0f, 1.0f, 1.0f };
+const __simdia_veclf __simdia_const_vonelf = { 1.0 , 1.0              };
 
 /***** Constant Two *****/
-const  __veci  __const_vtwoi = {   2 ,   2 ,   2 ,   2  };
-const  __vecf  __const_vtwof = { 2.0f, 2.0f, 2.0f, 2.0f };
-const __veclf __const_vtwolf = { 2.0 , 2.0              };
+const  __simdia_veci  __simdia_const_vtwoi = {   2 ,   2 ,   2 ,   2  };
+const  __simdia_vecf  __simdia_const_vtwof = { 2.0f, 2.0f, 2.0f, 2.0f };
+const __simdia_veclf __simdia_const_vtwolf = { 2.0 , 2.0              };
 
 /***** Constant Negative One *****/
-const  __veci  __const_vnegonei = {   -1 ,   -1 ,   -1 ,   -1  };
-const  __vecf  __const_vnegonef = { -1.0f, -1.0f, -1.0f, -1.0f };
-const __veclf __const_vnegonelf = { -1.0 , -1.0                };
+const  __simdia_veci  __simdia_const_vnegonei = {   -1 ,   -1 ,   -1 ,   -1  };
+const  __simdia_vecf  __simdia_const_vnegonef = { -1.0f, -1.0f, -1.0f, -1.0f };
+const __simdia_veclf __simdia_const_vnegonelf = { -1.0 , -1.0                };
 
 /* TODO | FIXME - Try to create constants such that it does not require a
  * memory operations to access the constants (like the SSE constants).
  */
 
 /***** Rotate *****/
-inline  __veci  __vrothi(const  __veci a, int s) {  __veci b;    int* a_ptr = (   int*)(&a);    int* b_ptr = (   int*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0-s)&0x3]; b_ptr[1] = a_ptr[(1-s)&0x3]; b_ptr[2] = a_ptr[(2-s)&0x3]; b_ptr[3] = a_ptr[(3-s)&0x3]; return b; }
-inline  __vecf  __vrothf(const  __vecf a, int s) {  __vecf b;  float* a_ptr = ( float*)(&a);  float* b_ptr = ( float*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0-s)&0x3]; b_ptr[1] = a_ptr[(1-s)&0x3]; b_ptr[2] = a_ptr[(2-s)&0x3]; b_ptr[3] = a_ptr[(3-s)&0x3]; return b; }
-inline __veclf __vrothlf(const __veclf a, int s) { __veclf b; double* a_ptr = (double*)(&a); double* b_ptr = (double*)(&b); s &= 0x1; b_ptr[0] = a_ptr[(0-s)&0x1]; b_ptr[1] = a_ptr[(1-s)&0x1]; return b; }
-inline  __veci  __vrotli(const  __veci a, int s) {  __veci b;    int* a_ptr = (   int*)(&a);    int* b_ptr = (   int*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0+s)&0x3]; b_ptr[1] = a_ptr[(1+s)&0x3]; b_ptr[2] = a_ptr[(2+s)&0x3]; b_ptr[3] = a_ptr[(3+s)&0x3]; return b; }
-inline  __vecf  __vrotlf(const  __vecf a, int s) {  __vecf b;  float* a_ptr = ( float*)(&a);  float* b_ptr = ( float*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0+s)&0x3]; b_ptr[1] = a_ptr[(1+s)&0x3]; b_ptr[2] = a_ptr[(2+s)&0x3]; b_ptr[3] = a_ptr[(3+s)&0x3]; return b; }
-inline __veclf __vrotllf(const __veclf a, int s) { __veclf b; double* a_ptr = (double*)(&a); double* b_ptr = (double*)(&b); s &= 0x1; b_ptr[0] = a_ptr[(0+s)&0x1]; b_ptr[1] = a_ptr[(1+s)&0x1]; return b; }
+inline  __simdia_veci  __simdia_vrothi(const  __simdia_veci a, int s) {  __simdia_veci b;    int* a_ptr = (   int*)(&a);    int* b_ptr = (   int*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0-s)&0x3]; b_ptr[1] = a_ptr[(1-s)&0x3]; b_ptr[2] = a_ptr[(2-s)&0x3]; b_ptr[3] = a_ptr[(3-s)&0x3]; return b; }
+inline  __simdia_vecf  __simdia_vrothf(const  __simdia_vecf a, int s) {  __simdia_vecf b;  float* a_ptr = ( float*)(&a);  float* b_ptr = ( float*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0-s)&0x3]; b_ptr[1] = a_ptr[(1-s)&0x3]; b_ptr[2] = a_ptr[(2-s)&0x3]; b_ptr[3] = a_ptr[(3-s)&0x3]; return b; }
+inline __simdia_veclf __simdia_vrothlf(const __simdia_veclf a, int s) { __simdia_veclf b; double* a_ptr = (double*)(&a); double* b_ptr = (double*)(&b); s &= 0x1; b_ptr[0] = a_ptr[(0-s)&0x1]; b_ptr[1] = a_ptr[(1-s)&0x1]; return b; }
+inline  __simdia_veci  __simdia_vrotli(const  __simdia_veci a, int s) {  __simdia_veci b;    int* a_ptr = (   int*)(&a);    int* b_ptr = (   int*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0+s)&0x3]; b_ptr[1] = a_ptr[(1+s)&0x3]; b_ptr[2] = a_ptr[(2+s)&0x3]; b_ptr[3] = a_ptr[(3+s)&0x3]; return b; }
+inline  __simdia_vecf  __simdia_vrotlf(const  __simdia_vecf a, int s) {  __simdia_vecf b;  float* a_ptr = ( float*)(&a);  float* b_ptr = ( float*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0+s)&0x3]; b_ptr[1] = a_ptr[(1+s)&0x3]; b_ptr[2] = a_ptr[(2+s)&0x3]; b_ptr[3] = a_ptr[(3+s)&0x3]; return b; }
+inline __simdia_veclf __simdia_vrotllf(const __simdia_veclf a, int s) { __simdia_veclf b; double* a_ptr = (double*)(&a); double* b_ptr = (double*)(&b); s &= 0x1; b_ptr[0] = a_ptr[(0+s)&0x1]; b_ptr[1] = a_ptr[(1+s)&0x1]; return b; }
 
 /***** Addition *****/
-inline  __veci  __vaddi(const  __veci a, const  __veci b) {  __veci r; r.v0 = a.v0 + b.v0; r.v1 = a.v1 + b.v1; r.v2 = a.v2 + b.v2; r.v3 = a.v3 + b.v3; return r; }
-inline  __vecf  __vaddf(const  __vecf a, const  __vecf b) {  __vecf r; r.v0 = a.v0 + b.v0; r.v1 = a.v1 + b.v1; r.v2 = a.v2 + b.v2; r.v3 = a.v3 + b.v3; return r; }
-inline __veclf __vaddlf(const __veclf a, const __veclf b) { __veclf r; r.v0 = a.v0 + b.v0; r.v1 = a.v1 + b.v1;                                         return r; }
+inline  __simdia_veci  __simdia_vaddi(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = a.v0 + b.v0; r.v1 = a.v1 + b.v1; r.v2 = a.v2 + b.v2; r.v3 = a.v3 + b.v3; return r; }
+inline  __simdia_vecf  __simdia_vaddf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; r.v0 = a.v0 + b.v0; r.v1 = a.v1 + b.v1; r.v2 = a.v2 + b.v2; r.v3 = a.v3 + b.v3; return r; }
+inline __simdia_veclf __simdia_vaddlf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; r.v0 = a.v0 + b.v0; r.v1 = a.v1 + b.v1;                                         return r; }
 
 /***** Subtraction *****/
-inline  __veci  __vsubi(const  __veci a, const  __veci b) {  __veci r; r.v0 = a.v0 - b.v0; r.v1 = a.v1 - b.v1; r.v2 = a.v2 - b.v2; r.v3 = a.v3 - b.v3; return r; }
-inline  __vecf  __vsubf(const  __vecf a, const  __vecf b) {  __vecf r; r.v0 = a.v0 - b.v0; r.v1 = a.v1 - b.v1; r.v2 = a.v2 - b.v2; r.v3 = a.v3 - b.v3; return r; }
-inline __veclf __vsublf(const __veclf a, const __veclf b) { __veclf r; r.v0 = a.v0 - b.v0; r.v1 = a.v1 - b.v1;                                         return r; }
+inline  __simdia_veci  __simdia_vsubi(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = a.v0 - b.v0; r.v1 = a.v1 - b.v1; r.v2 = a.v2 - b.v2; r.v3 = a.v3 - b.v3; return r; }
+inline  __simdia_vecf  __simdia_vsubf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; r.v0 = a.v0 - b.v0; r.v1 = a.v1 - b.v1; r.v2 = a.v2 - b.v2; r.v3 = a.v3 - b.v3; return r; }
+inline __simdia_veclf __simdia_vsublf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; r.v0 = a.v0 - b.v0; r.v1 = a.v1 - b.v1;                                         return r; }
 
 /***** Multiplication *****/
-inline  __veci  __vmuli(const  __veci a, const  __veci b) {  __veci r; r.v0 = a.v0 * b.v0; r.v1 = a.v1 * b.v1; r.v2 = a.v2 * b.v2; r.v3 = a.v3 * b.v3; return r; }
-inline  __vecf  __vmulf(const  __vecf a, const  __vecf b) {  __vecf r; r.v0 = a.v0 * b.v0; r.v1 = a.v1 * b.v1; r.v2 = a.v2 * b.v2; r.v3 = a.v3 * b.v3; return r; }
-inline __veclf __vmullf(const __veclf a, const __veclf b) { __veclf r; r.v0 = a.v0 * b.v0; r.v1 = a.v1 * b.v1;                                         return r; }
+inline  __simdia_veci  __simdia_vmuli(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = a.v0 * b.v0; r.v1 = a.v1 * b.v1; r.v2 = a.v2 * b.v2; r.v3 = a.v3 * b.v3; return r; }
+inline  __simdia_vecf  __simdia_vmulf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; r.v0 = a.v0 * b.v0; r.v1 = a.v1 * b.v1; r.v2 = a.v2 * b.v2; r.v3 = a.v3 * b.v3; return r; }
+inline __simdia_veclf __simdia_vmullf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; r.v0 = a.v0 * b.v0; r.v1 = a.v1 * b.v1;                                         return r; }
 
 /***** Division *****/
-inline  __veci  __vdivi(const  __veci a, const  __veci b) {  __veci r; r.v0 = a.v0 / b.v0; r.v1 = a.v1 / b.v1; r.v2 = a.v2 / b.v2; r.v3 = a.v3 / b.v3; return r; }
-inline  __vecf  __vdivf(const  __vecf a, const  __vecf b) {  __vecf r; r.v0 = a.v0 / b.v0; r.v1 = a.v1 / b.v1; r.v2 = a.v2 / b.v2; r.v3 = a.v3 / b.v3; return r; }
-inline __veclf __vdivlf(const __veclf a, const __veclf b) { __veclf r; r.v0 = a.v0 / b.v0; r.v1 = a.v1 / b.v1;                                         return r; }
+inline  __simdia_veci  __simdia_vdivi(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = a.v0 / b.v0; r.v1 = a.v1 / b.v1; r.v2 = a.v2 / b.v2; r.v3 = a.v3 / b.v3; return r; }
+inline  __simdia_vecf  __simdia_vdivf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; r.v0 = a.v0 / b.v0; r.v1 = a.v1 / b.v1; r.v2 = a.v2 / b.v2; r.v3 = a.v3 / b.v3; return r; }
+inline __simdia_veclf __simdia_vdivlf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; r.v0 = a.v0 / b.v0; r.v1 = a.v1 / b.v1;                                         return r; }
 
 /***** Fused Multiply Add *****/
-inline  __veci  __vmaddi(const  __veci a, const  __veci b, const  __veci c) {  __veci r; r.v0 = a.v0 * b.v0 + c.v0; r.v1 = a.v1 * b.v1 + c.v1; r.v2 = a.v2 * b.v2 + c.v2; r.v3 = a.v3 * b.v3 + c.v3; return r; }
-inline  __vecf  __vmaddf(const  __vecf a, const  __vecf b, const  __vecf c) {  __vecf r; r.v0 = a.v0 * b.v0 + c.v0; r.v1 = a.v1 * b.v1 + c.v1; r.v2 = a.v2 * b.v2 + c.v2; r.v3 = a.v3 * b.v3 + c.v3; return r; }
-inline __veclf __vmaddlf(const __veclf a, const __veclf b, const __veclf c) { __veclf r; r.v0 = a.v0 * b.v0 + c.v0; r.v1 = a.v1 * b.v1 + c.v1;                                                       return r; }
+inline  __simdia_veci  __simdia_vmaddi(const  __simdia_veci a, const  __simdia_veci b, const  __simdia_veci c) {  __simdia_veci r; r.v0 = a.v0 * b.v0 + c.v0; r.v1 = a.v1 * b.v1 + c.v1; r.v2 = a.v2 * b.v2 + c.v2; r.v3 = a.v3 * b.v3 + c.v3; return r; }
+inline  __simdia_vecf  __simdia_vmaddf(const  __simdia_vecf a, const  __simdia_vecf b, const  __simdia_vecf c) {  __simdia_vecf r; r.v0 = a.v0 * b.v0 + c.v0; r.v1 = a.v1 * b.v1 + c.v1; r.v2 = a.v2 * b.v2 + c.v2; r.v3 = a.v3 * b.v3 + c.v3; return r; }
+inline __simdia_veclf __simdia_vmaddlf(const __simdia_veclf a, const __simdia_veclf b, const __simdia_veclf c) { __simdia_veclf r; r.v0 = a.v0 * b.v0 + c.v0; r.v1 = a.v1 * b.v1 + c.v1;                                                       return r; }
 
 /***** Reciprocal *****/
 /* TODO | FIXME  - See if there is a better way to do this (few cycles and avoid the memory load) */
-inline  __vecf  __vrecipf(const  __vecf a) {  __vecf r; r.v0 = 1.0f / a.v0; r.v1 = 1.0f / a.v1; r.v2 = 1.0f / a.v2; r.v3 = 1.0f / a.v3; return r; }
-inline __veclf __vreciplf(const __veclf a) { __veclf r; r.v0 = 1.0f / a.v0; r.v1 = 1.0f / a.v1; return r; }
+inline  __simdia_vecf  __simdia_vrecipf(const  __simdia_vecf a) {  __simdia_vecf r; r.v0 = 1.0f / a.v0; r.v1 = 1.0f / a.v1; r.v2 = 1.0f / a.v2; r.v3 = 1.0f / a.v3; return r; }
+inline __simdia_veclf __simdia_vreciplf(const __simdia_veclf a) { __simdia_veclf r; r.v0 = 1.0f / a.v0; r.v1 = 1.0f / a.v1; return r; }
 
 /***** Square Root *****/
-inline  __vecf  __vsqrtf(const  __vecf a) {  __vecf r; r.v0 = sqrtf(a.v0); r.v1 = sqrtf(a.v1); r.v2 = sqrtf(a.v2); r.v3 = sqrtf(a.v3); return r; }
-inline __veclf __vsqrtlf(const __veclf a) { __veclf r; r.v0 = sqrt(a.v0); r.v1 = sqrt(a.v1); return r; }
+inline  __simdia_vecf  __simdia_vsqrtf(const  __simdia_vecf a) {  __simdia_vecf r; r.v0 = sqrtf(a.v0); r.v1 = sqrtf(a.v1); r.v2 = sqrtf(a.v2); r.v3 = sqrtf(a.v3); return r; }
+inline __simdia_veclf __simdia_vsqrtlf(const __simdia_veclf a) { __simdia_veclf r; r.v0 = sqrt(a.v0); r.v1 = sqrt(a.v1); return r; }
 
 /***** Reciprocal Square Root *****/
-inline  __vecf  __vrsqrtf(const  __vecf a) {  __vecf r; r.v0 = 1.0f / sqrtf(a.v0); r.v1 = 1.0f / sqrtf(a.v1); r.v2 = 1.0f / sqrtf(a.v2); r.v3 = 1.0f / sqrtf(a.v3); return r; }
-inline __veclf __vrsqrtlf(const __veclf a) { __veclf r; r.v0 = 1.0 / sqrt(a.v0); r.v1 = 1.0 / sqrt(a.v1); return r; }
+inline  __simdia_vecf  __simdia_vrsqrtf(const  __simdia_vecf a) {  __simdia_vecf r; r.v0 = 1.0f / sqrtf(a.v0); r.v1 = 1.0f / sqrtf(a.v1); r.v2 = 1.0f / sqrtf(a.v2); r.v3 = 1.0f / sqrtf(a.v3); return r; }
+inline __simdia_veclf __simdia_vrsqrtlf(const __simdia_veclf a) { __simdia_veclf r; r.v0 = 1.0 / sqrt(a.v0); r.v1 = 1.0 / sqrt(a.v1); return r; }
 
 /***** Not *****/
-inline  __veci  __vnoti(const  __veci a) {  __veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); rPtr[0] = aPtr[0] ^ -1; rPtr[1] = aPtr[1] ^ -1; rPtr[2] = aPtr[2] ^ -1; rPtr[3] = aPtr[3] ^ -1; return r; }
-inline  __vecf  __vnotf(const  __vecf a) {  __vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); rPtr[0] = aPtr[0] ^ -1; rPtr[1] = aPtr[1] ^ -1; rPtr[2] = aPtr[2] ^ -1; rPtr[3] = aPtr[3] ^ -1; return r; }
-inline __veclf __vnotlf(const __veclf a) { __veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); rPtr[0] = aPtr[0] ^ -1; rPtr[1] = aPtr[1] ^ -1; rPtr[2] = aPtr[2] ^ -1; rPtr[3] = aPtr[3] ^ -1; return r; }
+inline  __simdia_veci  __simdia_vnoti(const  __simdia_veci a) {  __simdia_veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); rPtr[0] = aPtr[0] ^ -1; rPtr[1] = aPtr[1] ^ -1; rPtr[2] = aPtr[2] ^ -1; rPtr[3] = aPtr[3] ^ -1; return r; }
+inline  __simdia_vecf  __simdia_vnotf(const  __simdia_vecf a) {  __simdia_vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); rPtr[0] = aPtr[0] ^ -1; rPtr[1] = aPtr[1] ^ -1; rPtr[2] = aPtr[2] ^ -1; rPtr[3] = aPtr[3] ^ -1; return r; }
+inline __simdia_veclf __simdia_vnotlf(const __simdia_veclf a) { __simdia_veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); rPtr[0] = aPtr[0] ^ -1; rPtr[1] = aPtr[1] ^ -1; rPtr[2] = aPtr[2] ^ -1; rPtr[3] = aPtr[3] ^ -1; return r; }
 
 /***** Or *****/
-inline  __veci  __vori(const  __veci a, const  __veci b) {  __veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] | bPtr[0]; rPtr[1] = aPtr[1] | bPtr[1]; rPtr[2] = aPtr[2] | bPtr[2]; rPtr[3] = aPtr[3] | bPtr[3]; return r; }
-inline  __vecf  __vorf(const  __vecf a, const  __vecf b) {  __vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] | bPtr[0]; rPtr[1] = aPtr[1] | bPtr[1]; rPtr[2] = aPtr[2] | bPtr[2]; rPtr[3] = aPtr[3] | bPtr[3]; return r; }
-inline __veclf __vorlf(const __veclf a, const __veclf b) { __veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] | bPtr[0]; rPtr[1] = aPtr[1] | bPtr[1]; rPtr[2] = aPtr[2] | bPtr[2]; rPtr[3] = aPtr[3] | bPtr[3]; return r; }
+inline  __simdia_veci  __simdia_vori(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] | bPtr[0]; rPtr[1] = aPtr[1] | bPtr[1]; rPtr[2] = aPtr[2] | bPtr[2]; rPtr[3] = aPtr[3] | bPtr[3]; return r; }
+inline  __simdia_vecf  __simdia_vorf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] | bPtr[0]; rPtr[1] = aPtr[1] | bPtr[1]; rPtr[2] = aPtr[2] | bPtr[2]; rPtr[3] = aPtr[3] | bPtr[3]; return r; }
+inline __simdia_veclf __simdia_vorlf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] | bPtr[0]; rPtr[1] = aPtr[1] | bPtr[1]; rPtr[2] = aPtr[2] | bPtr[2]; rPtr[3] = aPtr[3] | bPtr[3]; return r; }
 
 /***** Nor *****/
-inline  __veci  __vnori(const  __veci a, const  __veci b) {  __veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] | bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] | bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] | bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] | bPtr[3]) ^ -1; return r; }
-inline  __vecf  __vnorf(const  __vecf a, const  __vecf b) {  __vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] | bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] | bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] | bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] | bPtr[3]) ^ -1; return r; }
-inline __veclf __vnorlf(const __veclf a, const __veclf b) { __veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] | bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] | bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] | bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] | bPtr[3]) ^ -1; return r; }
+inline  __simdia_veci  __simdia_vnori(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] | bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] | bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] | bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] | bPtr[3]) ^ -1; return r; }
+inline  __simdia_vecf  __simdia_vnorf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] | bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] | bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] | bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] | bPtr[3]) ^ -1; return r; }
+inline __simdia_veclf __simdia_vnorlf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] | bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] | bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] | bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] | bPtr[3]) ^ -1; return r; }
 
 /***** And *****/
-inline  __veci  __vandi(const  __veci a, const  __veci b) {  __veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] & bPtr[0]; rPtr[1] = aPtr[1] & bPtr[1]; rPtr[2] = aPtr[2] & bPtr[2]; rPtr[3] = aPtr[3] & bPtr[3]; return r; }
-inline  __vecf  __vandf(const  __vecf a, const  __vecf b) {  __vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] & bPtr[0]; rPtr[1] = aPtr[1] & bPtr[1]; rPtr[2] = aPtr[2] & bPtr[2]; rPtr[3] = aPtr[3] & bPtr[3]; return r; }
-inline __veclf __vandlf(const __veclf a, const __veclf b) { __veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] & bPtr[0]; rPtr[1] = aPtr[1] & bPtr[1]; rPtr[2] = aPtr[2] & bPtr[2]; rPtr[3] = aPtr[3] & bPtr[3]; return r; }
+inline  __simdia_veci  __simdia_vandi(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] & bPtr[0]; rPtr[1] = aPtr[1] & bPtr[1]; rPtr[2] = aPtr[2] & bPtr[2]; rPtr[3] = aPtr[3] & bPtr[3]; return r; }
+inline  __simdia_vecf  __simdia_vandf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] & bPtr[0]; rPtr[1] = aPtr[1] & bPtr[1]; rPtr[2] = aPtr[2] & bPtr[2]; rPtr[3] = aPtr[3] & bPtr[3]; return r; }
+inline __simdia_veclf __simdia_vandlf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] & bPtr[0]; rPtr[1] = aPtr[1] & bPtr[1]; rPtr[2] = aPtr[2] & bPtr[2]; rPtr[3] = aPtr[3] & bPtr[3]; return r; }
 
 /***** Nand *****/
-inline  __veci  __vnandi(const  __veci a, const  __veci b) {  __veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] & bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] & bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] & bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] & bPtr[3]) ^ -1; return r; }
-inline  __vecf  __vnandf(const  __vecf a, const  __vecf b) {  __vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] & bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] & bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] & bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] & bPtr[3]) ^ -1; return r; }
-inline __veclf __vnandlf(const __veclf a, const __veclf b) { __veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] & bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] & bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] & bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] & bPtr[3]) ^ -1; return r; }
+inline  __simdia_veci  __simdia_vnandi(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] & bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] & bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] & bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] & bPtr[3]) ^ -1; return r; }
+inline  __simdia_vecf  __simdia_vnandf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] & bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] & bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] & bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] & bPtr[3]) ^ -1; return r; }
+inline __simdia_veclf __simdia_vnandlf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] & bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] & bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] & bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] & bPtr[3]) ^ -1; return r; }
 
 /***** Xor *****/
-inline  __veci  __vxori(const  __veci a, const  __veci b) {  __veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] ^ bPtr[0]; rPtr[1] = aPtr[1] ^ bPtr[1]; rPtr[2] = aPtr[2] ^ bPtr[2]; rPtr[3] = aPtr[3] ^ bPtr[3]; return r; }
-inline  __vecf  __vxorf(const  __vecf a, const  __vecf b) {  __vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] ^ bPtr[0]; rPtr[1] = aPtr[1] ^ bPtr[1]; rPtr[2] = aPtr[2] ^ bPtr[2]; rPtr[3] = aPtr[3] ^ bPtr[3]; return r; }
-inline __veclf __vxorlf(const __veclf a, const __veclf b) { __veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] ^ bPtr[0]; rPtr[1] = aPtr[1] ^ bPtr[1]; rPtr[2] = aPtr[2] ^ bPtr[2]; rPtr[3] = aPtr[3] ^ bPtr[3]; return r; }
+inline  __simdia_veci  __simdia_vxori(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] ^ bPtr[0]; rPtr[1] = aPtr[1] ^ bPtr[1]; rPtr[2] = aPtr[2] ^ bPtr[2]; rPtr[3] = aPtr[3] ^ bPtr[3]; return r; }
+inline  __simdia_vecf  __simdia_vxorf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] ^ bPtr[0]; rPtr[1] = aPtr[1] ^ bPtr[1]; rPtr[2] = aPtr[2] ^ bPtr[2]; rPtr[3] = aPtr[3] ^ bPtr[3]; return r; }
+inline __simdia_veclf __simdia_vxorlf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = aPtr[0] ^ bPtr[0]; rPtr[1] = aPtr[1] ^ bPtr[1]; rPtr[2] = aPtr[2] ^ bPtr[2]; rPtr[3] = aPtr[3] ^ bPtr[3]; return r; }
 
 /***** Nxor *****/
-inline  __veci  __vnxori(const  __veci a, const  __veci b) {  __veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] ^ bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] ^ bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] ^ bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] ^ bPtr[3]) ^ -1; return r; }
-inline  __vecf  __vnxorf(const  __vecf a, const  __vecf b) {  __vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] ^ bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] ^ bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] ^ bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] ^ bPtr[3]) ^ -1; return r; }
-inline __veclf __vnxorlf(const __veclf a, const __veclf b) { __veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] ^ bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] ^ bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] ^ bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] ^ bPtr[3]) ^ -1; return r; }
+inline  __simdia_veci  __simdia_vnxori(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] ^ bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] ^ bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] ^ bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] ^ bPtr[3]) ^ -1; return r; }
+inline  __simdia_vecf  __simdia_vnxorf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_vecf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] ^ bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] ^ bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] ^ bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] ^ bPtr[3]) ^ -1; return r; }
+inline __simdia_veclf __simdia_vnxorlf(const __simdia_veclf a, const __simdia_veclf b) { __simdia_veclf r; int* rPtr = (int*)(&r); int* aPtr = (int*)(&a); int* bPtr = (int*)(&b); rPtr[0] = (aPtr[0] ^ bPtr[0]) ^ -1; rPtr[1] = (aPtr[1] ^ bPtr[1]) ^ -1; rPtr[2] = (aPtr[2] ^ bPtr[2]) ^ -1; rPtr[3] = (aPtr[3] ^ bPtr[3]) ^ -1; return r; }
 
 /* TODO | FIXME - Try to do the comparisons in a branchless way */
 
 /***** Equal To *****/
-inline __veci  __vcmpeqi(const  __veci a, const  __veci b) {  __veci r; r.v0 = ((a.v0 == b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 == b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 == b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 == b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci  __vcmpeqf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = ((a.v0 == b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 == b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 == b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 == b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci __vcmpeqlf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r.v1 = ((a.v0 == b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 == b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmpeqi(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = ((a.v0 == b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 == b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 == b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 == b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmpeqf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = ((a.v0 == b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 == b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 == b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 == b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci __simdia_vcmpeqlf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = r.v1 = ((a.v0 == b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 == b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
 
 /***** Greater Than *****/
-inline __veci  __vcmpgti(const  __veci a, const  __veci b) {  __veci r; r.v0 = ((a.v0 > b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 > b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 > b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 > b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci  __vcmpgtf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = ((a.v0 > b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 > b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 > b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 > b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci __vcmpgtlf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r.v1 = ((a.v0 > b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 > b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmpgti(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = ((a.v0 > b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 > b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 > b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 > b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmpgtf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = ((a.v0 > b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 > b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 > b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 > b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci __simdia_vcmpgtlf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = r.v1 = ((a.v0 > b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 > b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
 
 /***** Greater Than Or Equal To *****/
-inline __veci  __vcmpgei(const  __veci a, const  __veci b) {  __veci r; r.v0 = ((a.v0 >= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 >= b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 >= b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 >= b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci  __vcmpgef(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = ((a.v0 >= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 >= b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 >= b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 >= b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci __vcmpgelf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r.v1 = ((a.v0 >= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 >= b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmpgei(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = ((a.v0 >= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 >= b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 >= b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 >= b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmpgef(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = ((a.v0 >= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 >= b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 >= b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 >= b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci __simdia_vcmpgelf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = r.v1 = ((a.v0 >= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 >= b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
 
 /***** Less Than *****/
-inline __veci  __vcmplti(const  __veci a, const  __veci b) {  __veci r; r.v0 = ((a.v0 < b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 < b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 < b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 < b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci  __vcmpltf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = ((a.v0 < b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 < b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 < b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 < b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci __vcmpltlf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r.v1 = ((a.v0 < b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 < b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmplti(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = ((a.v0 < b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 < b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 < b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 < b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmpltf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = ((a.v0 < b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 < b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 < b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 < b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci __simdia_vcmpltlf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = r.v1 = ((a.v0 < b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 < b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
 
 /***** Less Than Or Equal To *****/
-inline __veci  __vcmplei(const  __veci a, const  __veci b) {  __veci r; r.v0 = ((a.v0 <= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 <= b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 <= b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 <= b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci  __vcmplef(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = ((a.v0 <= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 <= b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 <= b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 <= b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
-inline __veci __vcmplelf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r.v1 = ((a.v0 <= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 <= b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmplei(const  __simdia_veci a, const  __simdia_veci b) {  __simdia_veci r; r.v0 = ((a.v0 <= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 <= b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 <= b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 <= b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci  __simdia_vcmplef(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = ((a.v0 <= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v1 = ((a.v1 <= b.v1) ? (0xFFFFFFFF) : (0x0)); r.v2 = ((a.v2 <= b.v2) ? (0xFFFFFFFF) : (0x0)); r.v3 = ((a.v3 <= b.v3) ? (0xFFFFFFFF) : (0x0)); return r; }
+inline __simdia_veci __simdia_vcmplelf(const  __simdia_vecf a, const  __simdia_vecf b) {  __simdia_veci r; r.v0 = r.v1 = ((a.v0 <= b.v0) ? (0xFFFFFFFF) : (0x0)); r.v2 = r.v3 = ((a.v1 <= b.v1) ? (0xFFFFFFFF) : (0x0)); return r; }
 
 
 /*******************************************************************************
@@ -231,101 +223,101 @@ inline __veci __vcmplelf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r
 #if defined(__cplusplus)
 
   /***** Addition *****/
-  inline  __veci operator+(const  __veci &a, const  __veci &b) { return  __vaddi(a, b); }
-  inline  __vecf operator+(const  __vecf &a, const  __vecf &b) { return  __vaddf(a, b); }
-  inline __veclf operator+(const __veclf &a, const __veclf &b) { return __vaddlf(a, b); }
-  inline  __veci operator+=( __veci &a, const  __veci &b) { a =  __vaddi(a, b); return a; }
-  inline  __vecf operator+=( __vecf &a, const  __vecf &b) { a =  __vaddf(a, b); return a; }
-  inline __veclf operator+=(__veclf &a, const __veclf &b) { a = __vaddlf(a, b); return a; }
-
-  inline  __veci operator+(const  __veci &a, const    int &b) { return  __vaddi(a,  __vseti(b)); }
-  inline  __vecf operator+(const  __vecf &a, const  float &b) { return  __vaddf(a,  __vsetf(b)); }
-  inline __veclf operator+(const __veclf &a, const double &b) { return __vaddlf(a, __vsetlf(b)); }
-  inline  __veci operator+=( __veci &a, const    int &b) { a =  __vaddi(a,  __vseti(b)); return a; }
-  inline  __vecf operator+=( __vecf &a, const  float &b) { a =  __vaddf(a,  __vsetf(b)); return a; }
-  inline __veclf operator+=(__veclf &a, const double &b) { a = __vaddlf(a, __vsetlf(b)); return a; }
+  inline  __simdia_veci operator+(const  __simdia_veci &a, const  __simdia_veci &b) { return  __simdia_vaddi(a, b); }
+  inline  __simdia_vecf operator+(const  __simdia_vecf &a, const  __simdia_vecf &b) { return  __simdia_vaddf(a, b); }
+  inline __simdia_veclf operator+(const __simdia_veclf &a, const __simdia_veclf &b) { return __simdia_vaddlf(a, b); }
+  inline  __simdia_veci operator+=( __simdia_veci &a, const  __simdia_veci &b) { a =  __simdia_vaddi(a, b); return a; }
+  inline  __simdia_vecf operator+=( __simdia_vecf &a, const  __simdia_vecf &b) { a =  __simdia_vaddf(a, b); return a; }
+  inline __simdia_veclf operator+=(__simdia_veclf &a, const __simdia_veclf &b) { a = __simdia_vaddlf(a, b); return a; }
+
+  inline  __simdia_veci operator+(const  __simdia_veci &a, const    int &b) { return  __simdia_vaddi(a,  __simdia_vseti(b)); }
+  inline  __simdia_vecf operator+(const  __simdia_vecf &a, const  float &b) { return  __simdia_vaddf(a,  __simdia_vsetf(b)); }
+  inline __simdia_veclf operator+(const __simdia_veclf &a, const double &b) { return __simdia_vaddlf(a, __simdia_vsetlf(b)); }
+  inline  __simdia_veci operator+=( __simdia_veci &a, const    int &b) { a =  __simdia_vaddi(a,  __simdia_vseti(b)); return a; }
+  inline  __simdia_vecf operator+=( __simdia_vecf &a, const  float &b) { a =  __simdia_vaddf(a,  __simdia_vsetf(b)); return a; }
+  inline __simdia_veclf operator+=(__simdia_veclf &a, const double &b) { a = __simdia_vaddlf(a, __simdia_vsetlf(b)); return a; }
 
   /***** Subtraction *****/
-  inline  __veci operator-(const  __veci &a, const  __veci &b) { return  __vsubi(a, b); }
-  inline  __vecf operator-(const  __vecf &a, const  __vecf &b) { return  __vsubf(a, b); }
-  inline __veclf operator-(const __veclf &a, const __veclf &b) { return __vsublf(a, b); }
-  inline  __veci operator-=( __veci &a, const  __veci &b) { a =  __vsubi(a, b); return a; }
-  inline  __vecf operator-=( __vecf &a, const  __vecf &b) { a =  __vsubf(a, b); return a; }
-  inline __veclf operator-=(__veclf &a, const __veclf &b) { a = __vsublf(a, b); return a; }
-
-  inline  __veci operator-(const  __veci &a, const    int &b) { return  __vsubi(a,  __vseti(b)); }
-  inline  __vecf operator-(const  __vecf &a, const  float &b) { return  __vsubf(a,  __vsetf(b)); }
-  inline __veclf operator-(const __veclf &a, const double &b) { return __vsublf(a, __vsetlf(b)); }
-  inline  __veci operator-=( __veci &a, const    int &b) { a =  __vsubi(a,  __vseti(b)); return a; }
-  inline  __vecf operator-=( __vecf &a, const  float &b) { a =  __vsubf(a,  __vsetf(b)); return a; }
-  inline __veclf operator-=(__veclf &a, const double &b) { a = __vsublf(a, __vsetlf(b)); return a; }
+  inline  __simdia_veci operator-(const  __simdia_veci &a, const  __simdia_veci &b) { return  __simdia_vsubi(a, b); }
+  inline  __simdia_vecf operator-(const  __simdia_vecf &a, const  __simdia_vecf &b) { return  __simdia_vsubf(a, b); }
+  inline __simdia_veclf operator-(const __simdia_veclf &a, const __simdia_veclf &b) { return __simdia_vsublf(a, b); }
+  inline  __simdia_veci operator-=( __simdia_veci &a, const  __simdia_veci &b) { a =  __simdia_vsubi(a, b); return a; }
+  inline  __simdia_vecf operator-=( __simdia_vecf &a, const  __simdia_vecf &b) { a =  __simdia_vsubf(a, b); return a; }
+  inline __simdia_veclf operator-=(__simdia_veclf &a, const __simdia_veclf &b) { a = __simdia_vsublf(a, b); return a; }
+
+  inline  __simdia_veci operator-(const  __simdia_veci &a, const    int &b) { return  __simdia_vsubi(a,  __simdia_vseti(b)); }
+  inline  __simdia_vecf operator-(const  __simdia_vecf &a, const  float &b) { return  __simdia_vsubf(a,  __simdia_vsetf(b)); }
+  inline __simdia_veclf operator-(const __simdia_veclf &a, const double &b) { return __simdia_vsublf(a, __simdia_vsetlf(b)); }
+  inline  __simdia_veci operator-=( __simdia_veci &a, const    int &b) { a =  __simdia_vsubi(a,  __simdia_vseti(b)); return a; }
+  inline  __simdia_vecf operator-=( __simdia_vecf &a, const  float &b) { a =  __simdia_vsubf(a,  __simdia_vsetf(b)); return a; }
+  inline __simdia_veclf operator-=(__simdia_veclf &a, const double &b) { a = __simdia_vsublf(a, __simdia_vsetlf(b)); return a; }
 
   /***** Multiplication *****/
-  inline  __vecf operator*(const  __vecf &a, const  __vecf &b) { return  __vmulf(a, b); }
-  inline __veclf operator*(const __veclf &a, const __veclf &b) { return __vmullf(a, b); }
-  inline  __vecf operator*=( __vecf &a, const  __vecf &b) { a =  __vmulf(a, b); return a; }
-  inline __veclf operator*=(__veclf &a, const __veclf &b) { a = __vmullf(a, b); return a; }
+  inline  __simdia_vecf operator*(const  __simdia_vecf &a, const  __simdia_vecf &b) { return  __simdia_vmulf(a, b); }
+  inline __simdia_veclf operator*(const __simdia_veclf &a, const __simdia_veclf &b) { return __simdia_vmullf(a, b); }
+  inline  __simdia_vecf operator*=( __simdia_vecf &a, const  __simdia_vecf &b) { a =  __simdia_vmulf(a, b); return a; }
+  inline __simdia_veclf operator*=(__simdia_veclf &a, const __simdia_veclf &b) { a = __simdia_vmullf(a, b); return a; }
 
-  inline  __vecf operator*(const  __vecf &a, const  float &b) { return  __vmulf(a,  __vsetf(b)); }
-  inline __veclf operator*(const __veclf &a, const double &b) { return __vmullf(a, __vsetlf(b)); }
-  inline  __vecf operator*=( __vecf &a, const  float &b) { a =  __vmulf(a,  __vsetf(b)); return a; }
-  inline __veclf operator*=(__veclf &a, const double &b) { a = __vmullf(a, __vsetlf(b)); return a; }
+  inline  __simdia_vecf operator*(const  __simdia_vecf &a, const  float &b) { return  __simdia_vmulf(a,  __simdia_vsetf(b)); }
+  inline __simdia_veclf operator*(const __simdia_veclf &a, const double &b) { return __simdia_vmullf(a, __simdia_vsetlf(b)); }
+  inline  __simdia_vecf operator*=( __simdia_vecf &a, const  float &b) { a =  __simdia_vmulf(a,  __simdia_vsetf(b)); return a; }
+  inline __simdia_veclf operator*=(__simdia_veclf &a, const double &b) { a = __simdia_vmullf(a, __simdia_vsetlf(b)); return a; }
 
   /***** Division *****/
-  inline  __vecf operator/(const  __vecf &a, const  __vecf &b) { return  __vdivf(a, b); }
-  inline __veclf operator/(const __veclf &a, const __veclf &b) { return __vdivlf(a, b); }
-  inline  __vecf operator/=( __vecf &a, const  __vecf &b) { a =  __vdivf(a, b); return a; }
-  inline __veclf operator/=(__veclf &a, const __veclf &b) { a = __vdivlf(a, b); return a; }
+  inline  __simdia_vecf operator/(const  __simdia_vecf &a, const  __simdia_vecf &b) { return  __simdia_vdivf(a, b); }
+  inline __simdia_veclf operator/(const __simdia_veclf &a, const __simdia_veclf &b) { return __simdia_vdivlf(a, b); }
+  inline  __simdia_vecf operator/=( __simdia_vecf &a, const  __simdia_vecf &b) { a =  __simdia_vdivf(a, b); return a; }
+  inline __simdia_veclf operator/=(__simdia_veclf &a, const __simdia_veclf &b) { a = __simdia_vdivlf(a, b); return a; }
 
-  inline  __vecf operator/(const  __vecf &a, const  float &b) { return  __vdivf(a,  __vsetf(b)); }
-  inline __veclf operator/(const __veclf &a, const double &b) { return __vdivlf(a, __vsetlf(b)); }
-  inline  __vecf operator/=( __vecf &a, const  float &b) { a =  __vdivf(a,  __vsetf(b)); return a; }
-  inline __veclf operator/=(__veclf &a, const double &b) { a = __vdivlf(a, __vsetlf(b)); return a; }
+  inline  __simdia_vecf operator/(const  __simdia_vecf &a, const  float &b) { return  __simdia_vdivf(a,  __simdia_vsetf(b)); }
+  inline __simdia_veclf operator/(const __simdia_veclf &a, const double &b) { return __simdia_vdivlf(a, __simdia_vsetlf(b)); }
+  inline  __simdia_vecf operator/=( __simdia_vecf &a, const  float &b) { a =  __simdia_vdivf(a,  __simdia_vsetf(b)); return a; }
+  inline __simdia_veclf operator/=(__simdia_veclf &a, const double &b) { a = __simdia_vdivlf(a, __simdia_vsetlf(b)); return a; }
 
   /***** Or *****/
-  inline  __veci operator|(const  __veci &a, const  __veci &b) { return  __vori(a, b); }
-  inline  __vecf operator|(const  __vecf &a, const  __vecf &b) { return  __vorf(a, b); }
-  inline __veclf operator|(const __veclf &a, const __veclf &b) { return __vorlf(a, b); }
-  inline  __veci operator|=( __veci &a, const  __veci &b) { a =  __vori(a, b); return a; }
-  inline  __vecf operator|=( __vecf &a, const  __vecf &b) { a =  __vorf(a, b); return a; }
-  inline __veclf operator|=(__veclf &a, const __veclf &b) { a = __vorlf(a, b); return a; }
-
-  inline  __veci operator|(const  __veci &a, const    int &b) { return  __vori(a,  __vseti(b)); }
-  inline  __vecf operator|(const  __vecf &a, const  float &b) { return  __vorf(a,  __vsetf(b)); }
-  inline __veclf operator|(const __veclf &a, const double &b) { return __vorlf(a, __vsetlf(b)); }
-  inline  __veci operator|=( __veci &a, const    int &b) { a =  __vori(a,  __vseti(b)); return a; }
-  inline  __vecf operator|=( __vecf &a, const  float &b) { a =  __vorf(a,  __vsetf(b)); return a; }
-  inline __veclf operator|=(__veclf &a, const double &b) { a = __vorlf(a, __vsetlf(b)); return a; }
+  inline  __simdia_veci operator|(const  __simdia_veci &a, const  __simdia_veci &b) { return  __simdia_vori(a, b); }
+  inline  __simdia_vecf operator|(const  __simdia_vecf &a, const  __simdia_vecf &b) { return  __simdia_vorf(a, b); }
+  inline __simdia_veclf operator|(const __simdia_veclf &a, const __simdia_veclf &b) { return __simdia_vorlf(a, b); }
+  inline  __simdia_veci operator|=( __simdia_veci &a, const  __simdia_veci &b) { a =  __simdia_vori(a, b); return a; }
+  inline  __simdia_vecf operator|=( __simdia_vecf &a, const  __simdia_vecf &b) { a =  __simdia_vorf(a, b); return a; }
+  inline __simdia_veclf operator|=(__simdia_veclf &a, const __simdia_veclf &b) { a = __simdia_vorlf(a, b); return a; }
+
+  inline  __simdia_veci operator|(const  __simdia_veci &a, const    int &b) { return  __simdia_vori(a,  __simdia_vseti(b)); }
+  inline  __simdia_vecf operator|(const  __simdia_vecf &a, const  float &b) { return  __simdia_vorf(a,  __simdia_vsetf(b)); }
+  inline __simdia_veclf operator|(const __simdia_veclf &a, const double &b) { return __simdia_vorlf(a, __simdia_vsetlf(b)); }
+  inline  __simdia_veci operator|=( __simdia_veci &a, const    int &b) { a =  __simdia_vori(a,  __simdia_vseti(b)); return a; }
+  inline  __simdia_vecf operator|=( __simdia_vecf &a, const  float &b) { a =  __simdia_vorf(a,  __simdia_vsetf(b)); return a; }
+  inline __simdia_veclf operator|=(__simdia_veclf &a, const double &b) { a = __simdia_vorlf(a, __simdia_vsetlf(b)); return a; }
 
   /***** And *****/
-  inline  __veci operator&(const  __veci &a, const  __veci &b) { return  __vandi(a, b); }
-  inline  __vecf operator&(const  __vecf &a, const  __vecf &b) { return  __vandf(a, b); }
-  inline __veclf operator&(const __veclf &a, const __veclf &b) { return __vandlf(a, b); }
-  inline  __veci operator&=( __veci &a, const  __veci &b) { a =  __vandi(a, b); return a; }
-  inline  __vecf operator&=( __vecf &a, const  __vecf &b) { a =  __vandf(a, b); return a; }
-  inline __veclf operator&=(__veclf &a, const __veclf &b) { a = __vandlf(a, b); return a; }
-
-  inline  __veci operator&(const  __veci &a, const    int &b) { return  __vandi(a,  __vseti(b)); }
-  inline  __vecf operator&(const  __vecf &a, const  float &b) { return  __vandf(a,  __vsetf(b)); }
-  inline __veclf operator&(const __veclf &a, const double &b) { return __vandlf(a, __vsetlf(b)); }
-  inline  __veci operator&=( __veci &a, const    int &b) { a =  __vandi(a,  __vseti(b)); return a; }
-  inline  __vecf operator&=( __vecf &a, const  float &b) { a =  __vandf(a,  __vsetf(b)); return a; }
-  inline __veclf operator&=(__veclf &a, const double &b) { a = __vandlf(a, __vsetlf(b)); return a; }
+  inline  __simdia_veci operator&(const  __simdia_veci &a, const  __simdia_veci &b) { return  __simdia_vandi(a, b); }
+  inline  __simdia_vecf operator&(const  __simdia_vecf &a, const  __simdia_vecf &b) { return  __simdia_vandf(a, b); }
+  inline __simdia_veclf operator&(const __simdia_veclf &a, const __simdia_veclf &b) { return __simdia_vandlf(a, b); }
+  inline  __simdia_veci operator&=( __simdia_veci &a, const  __simdia_veci &b) { a =  __simdia_vandi(a, b); return a; }
+  inline  __simdia_vecf operator&=( __simdia_vecf &a, const  __simdia_vecf &b) { a =  __simdia_vandf(a, b); return a; }
+  inline __simdia_veclf operator&=(__simdia_veclf &a, const __simdia_veclf &b) { a = __simdia_vandlf(a, b); return a; }
+
+  inline  __simdia_veci operator&(const  __simdia_veci &a, const    int &b) { return  __simdia_vandi(a,  __simdia_vseti(b)); }
+  inline  __simdia_vecf operator&(const  __simdia_vecf &a, const  float &b) { return  __simdia_vandf(a,  __simdia_vsetf(b)); }
+  inline __simdia_veclf operator&(const __simdia_veclf &a, const double &b) { return __simdia_vandlf(a, __simdia_vsetlf(b)); }
+  inline  __simdia_veci operator&=( __simdia_veci &a, const    int &b) { a =  __simdia_vandi(a,  __simdia_vseti(b)); return a; }
+  inline  __simdia_vecf operator&=( __simdia_vecf &a, const  float &b) { a =  __simdia_vandf(a,  __simdia_vsetf(b)); return a; }
+  inline __simdia_veclf operator&=(__simdia_veclf &a, const double &b) { a = __simdia_vandlf(a, __simdia_vsetlf(b)); return a; }
 
   /***** Xor *****/
-  inline  __veci operator^(const  __veci &a, const  __veci &b) { return  __vxori(a, b); }
-  inline  __vecf operator^(const  __vecf &a, const  __vecf &b) { return  __vxorf(a, b); }
-  inline __veclf operator^(const __veclf &a, const __veclf &b) { return __vxorlf(a, b); }
-  inline  __veci operator^=( __veci &a, const  __veci &b) { a =  __vxori(a, b); return a; }
-  inline  __vecf operator^=( __vecf &a, const  __vecf &b) { a =  __vxorf(a, b); return a; }
-  inline __veclf operator^=(__veclf &a, const __veclf &b) { a = __vxorlf(a, b); return a; }
-
-  inline  __veci operator^(const  __veci &a, const    int &b) { return  __vxori(a,  __vseti(b)); }
-  inline  __vecf operator^(const  __vecf &a, const  float &b) { return  __vxorf(a,  __vsetf(b)); }
-  inline __veclf operator^(const __veclf &a, const double &b) { return __vxorlf(a, __vsetlf(b)); }
-  inline  __veci operator^=( __veci &a, const    int &b) { a =  __vxori(a,  __vseti(b)); return a; }
-  inline  __vecf operator^=( __vecf &a, const  float &b) { a =  __vxorf(a,  __vsetf(b)); return a; }
-  inline __veclf operator^=(__veclf &a, const double &b) { a = __vxorlf(a, __vsetlf(b)); return a; }
+  inline  __simdia_veci operator^(const  __simdia_veci &a, const  __simdia_veci &b) { return  __simdia_vxori(a, b); }
+  inline  __simdia_vecf operator^(const  __simdia_vecf &a, const  __simdia_vecf &b) { return  __simdia_vxorf(a, b); }
+  inline __simdia_veclf operator^(const __simdia_veclf &a, const __simdia_veclf &b) { return __simdia_vxorlf(a, b); }
+  inline  __simdia_veci operator^=( __simdia_veci &a, const  __simdia_veci &b) { a =  __simdia_vxori(a, b); return a; }
+  inline  __simdia_vecf operator^=( __simdia_vecf &a, const  __simdia_vecf &b) { a =  __simdia_vxorf(a, b); return a; }
+  inline __simdia_veclf operator^=(__simdia_veclf &a, const __simdia_veclf &b) { a = __simdia_vxorlf(a, b); return a; }
+
+  inline  __simdia_veci operator^(const  __simdia_veci &a, const    int &b) { return  __simdia_vxori(a,  __simdia_vseti(b)); }
+  inline  __simdia_vecf operator^(const  __simdia_vecf &a, const  float &b) { return  __simdia_vxorf(a,  __simdia_vsetf(b)); }
+  inline __simdia_veclf operator^(const __simdia_veclf &a, const double &b) { return __simdia_vxorlf(a, __simdia_vsetlf(b)); }
+  inline  __simdia_veci operator^=( __simdia_veci &a, const    int &b) { a =  __simdia_vxori(a,  __simdia_vseti(b)); return a; }
+  inline  __simdia_vecf operator^=( __simdia_vecf &a, const  float &b) { a =  __simdia_vxorf(a,  __simdia_vsetf(b)); return a; }
+  inline __simdia_veclf operator^=(__simdia_veclf &a, const double &b) { a = __simdia_vxorlf(a, __simdia_vsetlf(b)); return a; }
 
 #endif /* defined(__cplusplus) */
 
@@ -337,162 +329,156 @@ inline __veci __vcmplelf(const  __vecf a, const  __vecf b) {  __veci r; r.v0 = r
  ***** SSE Support
  *******************************************************************************
  *******************************************************************************/
-#if defined(__SSE2__) && (!(FORCE_NO_SSE))
+#if defined(__SSE2__) && (!(SIMDIA_FORCE_NO_SSE))
 
   /* NOTE | TODO | FIXME : Add checks for various version of SSE.  For now, only
    *   support and assume that minimum level SSE2.
    */
 
   /***** Data Types *****/
-  typedef __m128i  veci;
-  typedef  __m128  vecf;
-  typedef __m128d veclf;
+  typedef __m128i  simdia_veci;
+  typedef  __m128  simdia_vecf;
+  typedef __m128d simdia_veclf;
 
   /***** Insert *****/
   /* TODO | FIXME - Try to make these functions not reference memory so values stay in registers */
-  inline  veci  vinserti( veci v, const    int s, const int i) {  veci r = v;    int* rPtr = (   int*)(&r); rPtr[i] = s; return r; }
-  inline  vecf  vinsertf( vecf v, const  float s, const int i) {  vecf r = v;  float* rPtr = ( float*)(&r); rPtr[i] = s; return r; }
-  inline veclf vinsertlf(veclf v, const double s, const int i) { veclf r = v; double* rPtr = (double*)(&r); rPtr[i] = s; return r; }
+  inline  simdia_veci  simdia_vinserti( simdia_veci v, const    int s, const int i) {  simdia_veci r = v;    int* rPtr = (   int*)(&r); rPtr[i] = s; return r; }
+  inline  simdia_vecf  simdia_vinsertf( simdia_vecf v, const  float s, const int i) {  simdia_vecf r = v;  float* rPtr = ( float*)(&r); rPtr[i] = s; return r; }
+  inline simdia_veclf simdia_vinsertlf(simdia_veclf v, const double s, const int i) { simdia_veclf r = v; double* rPtr = (double*)(&r); rPtr[i] = s; return r; }
 
   /***** Extract *****/
   /* TODO | FIXME - Try to make these functions not reference memory so values stay in registers */
-  inline    int  vextracti( veci v, const int i) { return ((   int*)(&v))[i]; }
-  inline  float  vextractf( vecf v, const int i) { return (( float*)(&v))[i]; }
-  inline double vextractlf(veclf v, const int i) { return ((double*)(&v))[i]; }
-
+  inline    int  vextracti( simdia_veci v, const int i) { return ((   int*)(&v))[i]; }
+  inline  float  vextractf( simdia_vecf v, const int i) { return (( float*)(&v))[i]; }
+  inline double vextractlf(simdia_veclf v, const int i) { return ((double*)(&v))[i]; }
 
   /***** Set *****/
-  #define  vseti(a)  (_mm_set1_epi32((int)(a)))
-  #define  vsetf(a)  (_mm_set1_ps((float)(a)))
-  #define vsetlf(a)  (_mm_set1_pd((double)(a)))
+  #define  simdia_vseti(a)  (_mm_set1_epi32((int)(a)))
+  #define  simdia_vsetf(a)  (_mm_set1_ps((float)(a)))
+  #define simdia_vsetlf(a)  (_mm_set1_pd((double)(a)))
 
   /***** Constant Zero *****/
-  #define  const_vzeroi  (_mm_setzero_si128())
-  #define  const_vzerof  (_mm_setzero_ps())
-  #define const_vzerolf  (_mm_setzero_pd())
+  #define  simdia_const_vzeroi  (_mm_setzero_si128())
+  #define  simdia_const_vzerof  (_mm_setzero_ps())
+  #define simdia_const_vzerolf  (_mm_setzero_pd())
 
   /***** Constant One *****/
-  #define  const_vonei  (vseti(1))
-  #define  const_vonef  (vsetf(1.0f))
-  #define const_vonelf  (vsetlf(1.0))
+  #define  simdia_const_vonei  (simdia_vseti(1))
+  #define  simdia_const_vonef  (simdia_vsetf(1.0f))
+  #define simdia_const_vonelf  (simdia_vsetlf(1.0))
 
   /***** Constant Two *****/
-  #define  const_vtwoi  (vseti(2))
-  #define  const_vtwof  (vsetf(2.0f))
-  #define const_vtwolf  (vsetlf(2.0))
+  #define  simdia_const_vtwoi  (simdia_vseti(2))
+  #define  simdia_const_vtwof  (simdia_vsetf(2.0f))
+  #define simdia_const_vtwolf  (simdia_vsetlf(2.0))
 
   /***** Constant Negative One *****/
-  #define  const_vnegonei  (vseti(-1))
-  #define  const_vnegonef  (vsetf(-1.0f))
-  #define const_vnegonelf  (vsetlf(-1.0))
+  #define  simdia_const_vnegonei  (simdia_vseti(-1))
+  #define  simdia_const_vnegonef  (simdia_vsetf(-1.0f))
+  #define simdia_const_vnegonelf  (simdia_vsetlf(-1.0))
 
   /***** Rotate *****/
   /* TODO : FIXME - Find a better way to do Rotate in SSE */
-  inline  veci  vrothi(const  veci &a, int s) {  veci b;    int* a_ptr = (   int*)(&a);    int* b_ptr = (   int*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0-s)&0x3]; b_ptr[1] = a_ptr[(1-s)&0x3]; b_ptr[2] = a_ptr[(2-s)&0x3]; b_ptr[3] = a_ptr[(3-s)&0x3]; return b; }
-  inline  vecf  vrothf(const  vecf &a, int s) {  vecf b;  float* a_ptr = ( float*)(&a);  float* b_ptr = ( float*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0-s)&0x3]; b_ptr[1] = a_ptr[(1-s)&0x3]; b_ptr[2] = a_ptr[(2-s)&0x3]; b_ptr[3] = a_ptr[(3-s)&0x3]; return b; }
-  inline veclf vrothlf(const veclf &a, int s) { veclf b; double* a_ptr = (double*)(&a); double* b_ptr = (double*)(&b); s &= 0x1; b_ptr[0] = a_ptr[(0-s)&0x1]; b_ptr[1] = a_ptr[(1-s)&0x1]; return b; }
-  inline  veci  vrotli(const  veci &a, int s) {  veci b;    int* a_ptr = (   int*)(&a);    int* b_ptr = (   int*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0+s)&0x3]; b_ptr[1] = a_ptr[(1+s)&0x3]; b_ptr[2] = a_ptr[(2+s)&0x3]; b_ptr[3] = a_ptr[(3+s)&0x3]; return b; }
-  inline  vecf  vrotlf(const  vecf &a, int s) {  vecf b;  float* a_ptr = ( float*)(&a);  float* b_ptr = ( float*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0+s)&0x3]; b_ptr[1] = a_ptr[(1+s)&0x3]; b_ptr[2] = a_ptr[(2+s)&0x3]; b_ptr[3] = a_ptr[(3+s)&0x3]; return b; }
-  inline veclf vrotllf(const veclf &a, int s) { veclf b; double* a_ptr = (double*)(&a); double* b_ptr = (double*)(&b); s &= 0x1; b_ptr[0] = a_ptr[(0+s)&0x1]; b_ptr[1] = a_ptr[(1+s)&0x1]; return b; }
+  inline  simdia_veci  simdia_vrothi(const  simdia_veci &a, int s) {  simdia_veci b;    int* a_ptr = (   int*)(&a);    int* b_ptr = (   int*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0-s)&0x3]; b_ptr[1] = a_ptr[(1-s)&0x3]; b_ptr[2] = a_ptr[(2-s)&0x3]; b_ptr[3] = a_ptr[(3-s)&0x3]; return b; }
+  inline  simdia_vecf  simdia_vrothf(const  simdia_vecf &a, int s) {  simdia_vecf b;  float* a_ptr = ( float*)(&a);  float* b_ptr = ( float*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0-s)&0x3]; b_ptr[1] = a_ptr[(1-s)&0x3]; b_ptr[2] = a_ptr[(2-s)&0x3]; b_ptr[3] = a_ptr[(3-s)&0x3]; return b; }
+  inline simdia_veclf simdia_vrothlf(const simdia_veclf &a, int s) { simdia_veclf b; double* a_ptr = (double*)(&a); double* b_ptr = (double*)(&b); s &= 0x1; b_ptr[0] = a_ptr[(0-s)&0x1]; b_ptr[1] = a_ptr[(1-s)&0x1]; return b; }
+  inline  simdia_veci  simdia_vrotli(const  simdia_veci &a, int s) {  simdia_veci b;    int* a_ptr = (   int*)(&a);    int* b_ptr = (   int*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0+s)&0x3]; b_ptr[1] = a_ptr[(1+s)&0x3]; b_ptr[2] = a_ptr[(2+s)&0x3]; b_ptr[3] = a_ptr[(3+s)&0x3]; return b; }
+  inline  simdia_vecf  simdia_vrotlf(const  simdia_vecf &a, int s) {  simdia_vecf b;  float* a_ptr = ( float*)(&a);  float* b_ptr = ( float*)(&b); s &= 0x3; b_ptr[0] = a_ptr[(0+s)&0x3]; b_ptr[1] = a_ptr[(1+s)&0x3]; b_ptr[2] = a_ptr[(2+s)&0x3]; b_ptr[3] = a_ptr[(3+s)&0x3]; return b; }
+  inline simdia_veclf simdia_vrotllf(const simdia_veclf &a, int s) { simdia_veclf b; double* a_ptr = (double*)(&a); double* b_ptr = (double*)(&b); s &= 0x1; b_ptr[0] = a_ptr[(0+s)&0x1]; b_ptr[1] = a_ptr[(1+s)&0x1]; return b; }
 
   /***** Addition *****/
-  #define  vaddi(a, b)  (_mm_add_epi32((a), (b)))
-  #define  vaddf(a, b)  (_mm_add_ps((a), (b)))
-  #define vaddlf(a, b)  (_mm_add_pd((a), (b)))
+  #define  simdia_vaddi(a, b)  (_mm_add_epi32((a), (b)))
+  #define  simdia_vaddf(a, b)  (_mm_add_ps((a), (b)))
+  #define simdia_vaddlf(a, b)  (_mm_add_pd((a), (b)))
 
   /***** Subtraction *****/
-  #define  vsubi(a, b)  (_mm_sub_epi32((a), (b)))
-  #define  vsubf(a, b)  (_mm_sub_ps((a), (b)))
-  #define vsublf(a, b)  (_mm_sub_pd((a), (b)))
+  #define  simdia_vsubi(a, b)  (_mm_sub_epi32((a), (b)))
+  #define  simdia_vsubf(a, b)  (_mm_sub_ps((a), (b)))
+  #define simdia_vsublf(a, b)  (_mm_sub_pd((a), (b)))
 
   /***** Multiplication *****/
-  #define    vmulf(a, b)  (_mm_mul_ps((a), (b)))
-  #define   vmullf(a, b)  (_mm_mul_pd((a), (b)))
+  #define    simdia_vmulf(a, b)  (_mm_mul_ps((a), (b)))
+  #define   simdia_vmullf(a, b)  (_mm_mul_pd((a), (b)))
 
   /***** Division *****/
-  #define   vdivf(a, b)  (_mm_div_ps((a), (b)))
-  #define  vdivlf(a, b)  (_mm_div_pd((a), (b)))
+  #define   simdia_vdivf(a, b)  (_mm_div_ps((a), (b)))
+  #define  simdia_vdivlf(a, b)  (_mm_div_pd((a), (b)))
 
   /***** Fused Multiply Add *****/
-  #define  vmaddf(a, b, c)  ( vaddf( vmulf((a), (b)), (c)))
-  #define vmaddlf(a, b, c)  (vaddlf(vmullf((a), (b)), (c)))
+  #define  simdia_vmaddf(a, b, c)  ( vaddf( vmulf((a), (b)), (c)))
+  #define simdia_vmaddlf(a, b, c)  (vaddlf(vmullf((a), (b)), (c)))
 
   /***** Reciprocal *****/
-  #define  vrecipf(a)  (_mm_rcp_ps(a))
-
-// why, oh why hath the SSE2 developers forsaken us?
-//  #define vreciplf(a)  (_mm_rcp_pd(a)) <-- no worky
-
-// vrecip goes to a not very vector implementation
-inline veclf vreciplf(const veclf a) { veclf r; double* a_ptr =  (double*)(&a); double* r_ptr = (double*)(&r); r_ptr[0] = 1.0f /  a_ptr[0]; r_ptr[1] = 1.0f / a_ptr[1]; return r; }
+  #define  simdia_vrecipf(a)  (_mm_rcp_ps(a))
+  inline simdia_veclf simdia_vreciplf(const simdia_veclf a) { simdia_veclf r; double* a_ptr =  (double*)(&a); double* r_ptr = (double*)(&r); r_ptr[0] = 1.0f /  a_ptr[0]; r_ptr[1] = 1.0f / a_ptr[1]; return r; }
 
   /***** Square Root *****/
-  #define  vsqrtf(a)  (_mm_sqrt_ps(a))
-  #define vsqrtlf(a)  (_mm_sqrt_pd(a))
+  #define  simdia_vsqrtf(a)  (_mm_sqrt_ps(a))
+  #define simdia_vsqrtlf(a)  (_mm_sqrt_pd(a))
 
   /***** Reciprocal Square Root *****/
-  #define  vrsqrtf(a)  (_mm_rsqrt_ps(a))
-  #define vrsqrtlf(a)  (vreciplf(vsqrtlf(a)))
+  #define  simdia_vrsqrtf(a)  (_mm_rsqrt_ps(a))
+  #define simdia_vrsqrtlf(a)  (vreciplf(vsqrtlf(a)))
 
   /***** Not *****/
-  #define  vnoti(a)  (_mm_xor_si128((a), const_vnegonei))
-  #define  vnotf(a)  (_mm_xor_ps((a), const_vnegonei))
-  #define vnotlf(a)  (_mm_xor_pd((a), const_vnegonei))
+  #define  simdia_vnoti(a)  (_mm_xor_si128((a), simdia_const_vnegonei))
+  #define  simdia_vnotf(a)  (_mm_xor_ps((a), simdia_const_vnegonei))
+  #define simdia_vnotlf(a)  (_mm_xor_pd((a), simdia_const_vnegonei))
 
   /***** Or *****/
-  #define  vori(a, b)  (_mm_or_si128((a), (b)))
-  #define  vorf(a, b)  (_mm_or_ps((a), (b)))
-  #define vorlf(a, b)  (_mm_or_pd((a), (b)))
+  #define  simdia_vori(a, b)  (_mm_or_si128((a), (b)))
+  #define  simdia_vorf(a, b)  (_mm_or_ps((a), (b)))
+  #define simdia_vorlf(a, b)  (_mm_or_pd((a), (b)))
 
   /***** Nor *****/
-  #define  vnori(a, b)  ( vnoti( vori((a), (b))))
-  #define  vnorf(a, b)  ( vnotf( vorf((a), (b))))
-  #define vnorlf(a, b)  (vnotlf(vorlf((a), (b))))
+  #define  simdia_vnori(a, b)  ( simdia_vnoti( simdia_vori((a), (b))))
+  #define  simdia_vnorf(a, b)  ( simdia_vnotf( simdia_vorf((a), (b))))
+  #define simdia_vnorlf(a, b)  (simdia_vnotlf(simdia_vorlf((a), (b))))
 
   /***** And *****/
-  #define  vandi(a, b)  (_mm_and_si128((a), (b)))
-  #define  vandf(a, b)  (_mm_and_ps((a), (b)))
-  #define vandlf(a, b)  (_mm_and_pd((a), (b)))
+  #define  simdia_vandi(a, b)  (_mm_and_si128((a), (b)))
+  #define  simdia_vandf(a, b)  (_mm_and_ps((a), (b)))
+  #define simdia_vandlf(a, b)  (_mm_and_pd((a), (b)))
 
   /***** Nand *****/
-  #define  vnandi(a, b)  ( vnoti( vandi((a), (b))))
-  #define  vnandf(a, b)  ( vnotf( vandf((a), (b))))
-  #define vnandlf(a, b)  (vnotlf(vandlf((a), (b))))
+  #define  simdia_vnandi(a, b)  ( simdia_vnoti( simdia_vandi((a), (b))))
+  #define  simdia_vnandf(a, b)  ( simdia_vnotf( simdia_vandf((a), (b))))
+  #define simdia_vnandlf(a, b)  (simdia_vnotlf(simdia_vandlf((a), (b))))
 
   /***** Xor *****/
-  #define  vxori(a, b)  (_mm_xor_si128((a), (b)))
-  #define  vxorf(a, b)  (_mm_xor_ps((a), (b)))
-  #define vxorlf(a, b)  (_mm_xor_pd((a), (b)))
+  #define  simdia_vxori(a, b)  (_mm_xor_si128((a), (b)))
+  #define  simdia_vxorf(a, b)  (_mm_xor_ps((a), (b)))
+  #define simdia_vxorlf(a, b)  (_mm_xor_pd((a), (b)))
 
   /***** Nxor *****/
-  #define  vnxori(a, b)  ( vnoti( vxori((a), (b))))
-  #define  vnxorf(a, b)  ( vnotf( vxorf((a), (b))))
-  #define vnxorlf(a, b)  (vnotlf(vxorlf((a), (b))))
+  #define  simdia_vnxori(a, b)  ( simdia_vnoti( simdia_vxori((a), (b))))
+  #define  simdia_vnxorf(a, b)  ( simdia_vnotf( simdia_vxorf((a), (b))))
+  #define simdia_vnxorlf(a, b)  (simdia_vnotlf(simdia_vxorlf((a), (b))))
 
   /***** Equal To *****/
-  #define  vcmpeqi(a, b)  ((_m128i)(_mm_cmpeq_epi32((a), (b))))
-  #define  vcmpeqf(a, b)  ((_m128i)(_mm_cmpeq_ps((a), (b))))
-  #define vcmpeqlf(a, b)  ((_m128i)(_mm_cmpeq_pd((a), (b))))
+  #define  simdia_vcmpeqi(a, b)  ((simdia_veci)(_mm_cmpeq_epi32((a), (b))))
+  #define  simdia_vcmpeqf(a, b)  ((simdia_veci)(_mm_cmpeq_ps((a), (b))))
+  #define simdia_vcmpeqlf(a, b)  ((simdia_veci)(_mm_cmpeq_pd((a), (b))))
 
   /***** Greater Than *****/
-  #define  vcmpgti(a, b)  ((_m128i)(_mm_cmpgt_epi32((a), (b))))
-  #define  vcmpgtf(a, b)  ((_m128i)(_mm_cmpgt_ps((a), (b))))
-  #define vcmpgtlf(a, b)  ((_m128i)(_mm_cmpgt_pd((a), (b))))
+  #define  simdia_vcmpgti(a, b)  ((simdia_veci)(_mm_cmpgt_epi32((a), (b))))
+  #define  simdia_vcmpgtf(a, b)  ((simdia_veci)(_mm_cmpgt_ps((a), (b))))
+  #define simdia_vcmpgtlf(a, b)  ((simdia_veci)(_mm_cmpgt_pd((a), (b))))
 
   /***** Greater Than Or Equal To *****/
-  #define  vcmpgei(a, b)  ((_m128i)(_mm_cmpge_epi32((a), (b))))
-  #define  vcmpgef(a, b)  ((_m128i)(_mm_cmpge_ps((a), (b))))
-  #define vcmpgelf(a, b)  ((_m128i)(_mm_cmpge_pd((a), (b))))
+  #define  simdia_vcmpgei(a, b)  ((simdia_veci)(_mm_cmpge_epi32((a), (b))))
+  #define  simdia_vcmpgef(a, b)  ((simdia_veci)(_mm_cmpge_ps((a), (b))))
+  #define simdia_vcmpgelf(a, b)  ((simdia_veci)(_mm_cmpge_pd((a), (b))))
 
   /***** Less Than *****/
-  #define  vcmplti(a, b)  ((_m128i)(_mm_cmplt_epi32((a), (b))))
-  #define  vcmpltf(a, b)  ((_m128i)(_mm_cmplt_ps((a), (b))))
-  #define vcmpltlf(a, b)  ((_m128i)(_mm_cmplt_pd((a), (b))))
+  #define  simdia_vcmplti(a, b)  ((simdia_veci)(_mm_cmplt_epi32((a), (b))))
+  #define  simdia_vcmpltf(a, b)  ((simdia_veci)(_mm_cmplt_ps((a), (b))))
+  #define simdia_vcmpltlf(a, b)  ((simdia_veci)(_mm_cmplt_pd((a), (b))))
 
   /***** Less Than Or Equal To *****/
-  #define  vcmplei(a, b)  ((_m128i)(_mm_cmple_epi32((a), (b))))
-  #define  vcmplef(a, b)  ((_m128i)(_mm_cmple_ps((a), (b))))
-  #define vcmplelf(a, b)  ((_m128i)(_mm_cmple_pd((a), (b))))
+  #define  simdia_vcmplei(a, b)  ((simdia_veci)(_mm_cmple_epi32((a), (b))))
+  #define  simdia_vcmplef(a, b)  ((simdia_veci)(_mm_cmple_ps((a), (b))))
+  #define simdia_vcmplelf(a, b)  ((simdia_veci)(_mm_cmple_pd((a), (b))))
 
 
 /*******************************************************************************
@@ -501,151 +487,151 @@ inline veclf vreciplf(const veclf a) { veclf r; double* a_ptr =  (double*)(&a);
  *******************************************************************************
  *******************************************************************************/
 /* TODO | FIXME : Find a more general check for this (this is Charm++ specific) */
-#elif (CMK_CELL_SPE != 0) && (!(FORCE_NO_SPE_SIMD))
+#elif (CMK_CELL_SPE != 0) && (!(SIMDIA_FORCE_NO_SPE_SIMD))
 
   /***** Data Types *****/
-  typedef vector signed int veci;
-  typedef vector float vecf;
-  typedef vector double veclf;
+  typedef vector signed int  simdia_veci;
+  typedef vector float       simdia_vecf;
+  typedef vector double     simdia_veclf;
 
   /***** Insert *****/
-  #define  vinserti(v, s, i)  (spu_insert((s), (v), (i)))
-  #define  vinsertf(v, s, i)  (spu_insert((s), (v), (i)))
-  #define vinsertlf(v, s, i)  (spu_insert((s), (v), (i)))
+  #define  simdia_vinserti(v, s, i)  (spu_insert((s), (v), (i)))
+  #define  simdia_vinsertf(v, s, i)  (spu_insert((s), (v), (i)))
+  #define simdia_vinsertlf(v, s, i)  (spu_insert((s), (v), (i)))
 
   /***** Extract *****/
-  #define  vextracti(v, i)  (spu_extract((v), (i)))
-  #define  vextractf(v, i)  (spu_extract((v), (i)))
-  #define vextractlf(v, i)  (spu_extract((v), (i)))
+  #define  simdia_vextracti(v, i)  (spu_extract((v), (i)))
+  #define  simdia_vextractf(v, i)  (spu_extract((v), (i)))
+  #define simdia_vextractlf(v, i)  (spu_extract((v), (i)))
 
   /***** Set *****/
-  #define  vseti(a)  (spu_splats((int)(a)))
-  #define  vsetf(a)  (spu_splats((float)(a)))
-  #define vsetlf(a)  (spu_splats((double)(a)))
+  #define  simdia_vseti(a)  (spu_splats((int)(a)))
+  #define  simdia_vsetf(a)  (spu_splats((float)(a)))
+  #define simdia_vsetlf(a)  (spu_splats((double)(a)))
 
   /***** Constant Zero *****/
-  #define  const_vzeroi  (vseti(0))
-  #define  const_vzerof  (vsetf(0.0f))
-  #define const_vzerolf  (vsetlf(0.0))
+  #define  simdia_const_vzeroi  (vseti(0))
+  #define  simdia_const_vzerof  (vsetf(0.0f))
+  #define simdia_const_vzerolf  (vsetlf(0.0))
 
   /***** Constant One *****/
-  #define  const_vonei  (vseti(1))
-  #define  const_vonef  (vsetf(1.0f))
-  #define const_vonelf  (vsetlf(1.0))
+  #define  simdia_const_vonei  (vseti(1))
+  #define  simdia_const_vonef  (vsetf(1.0f))
+  #define simdia_const_vonelf  (vsetlf(1.0))
 
   /***** Constant Two *****/
-  #define  const_vtwoi  (vseti(2))
-  #define  const_vtwof  (vsetf(2.0f))
-  #define const_vtwolf  (vsetlf(2.0))
+  #define  simdia_const_vtwoi  (vseti(2))
+  #define  simdia_const_vtwof  (vsetf(2.0f))
+  #define simdia_const_vtwolf  (vsetlf(2.0))
 
   /***** Constant Negative One *****/
-  #define  const_vnegonei  (vseti(-1))
-  #define  const_vnegonef  (vsetf(-1.0f))
-  #define const_vnegonelf  (vsetlf(-1.0))
+  #define  simdia_const_vnegonei  (vseti(-1))
+  #define  simdia_const_vnegonef  (vsetf(-1.0f))
+  #define simdia_const_vnegonelf  (vsetlf(-1.0))
 
   /***** Rotate *****/
-  #define   vrothi(a, s) (spu_rlqwbyte((a), (0x10-(((s)&0x3)<<2)) ))
-  #define   vrothf(a, s) (spu_rlqwbyte((a), (0x10-(((s)&0x3)<<2)) ))
-  #define  vrothlf(a, s) (spu_rlqwbyte((a),       (((s)&0x1)<<3)  ))
-  #define   vrotli(a, s) (spu_rlqwbyte((a), ((s)&0x3)<<2))
-  #define   vrotlf(a, s) (spu_rlqwbyte((a), ((s)&0x3)<<2))
-  #define  vrotllf(a, s) (spu_rlqwbyte((a), ((s)&0x1)<<3))
+  #define   simdia_vrothi(a, s) (spu_rlqwbyte((a), (0x10-(((s)&0x3)<<2)) ))
+  #define   simdia_vrothf(a, s) (spu_rlqwbyte((a), (0x10-(((s)&0x3)<<2)) ))
+  #define  simdia_vrothlf(a, s) (spu_rlqwbyte((a),       (((s)&0x1)<<3)  ))
+  #define   simdia_vrotli(a, s) (spu_rlqwbyte((a), ((s)&0x3)<<2))
+  #define   simdia_vrotlf(a, s) (spu_rlqwbyte((a), ((s)&0x3)<<2))
+  #define  simdia_vrotllf(a, s) (spu_rlqwbyte((a), ((s)&0x1)<<3))
 
   /***** Addition *****/
-  #define  vaddi(a, b)  (spu_add((a), (b)))
-  #define  vaddf(a, b)  (spu_add((a), (b)))
-  #define vaddlf(a, b)  (spu_add((a), (b)))
+  #define  simdia_vaddi(a, b)  (spu_add((a), (b)))
+  #define  simdia_vaddf(a, b)  (spu_add((a), (b)))
+  #define simdia_vaddlf(a, b)  (spu_add((a), (b)))
 
   /***** Subtraction *****/
-  #define  vsubi(a, b)  (spu_sub((a), (b)))
-  #define  vsubf(a, b)  (spu_sub((a), (b)))
-  #define vsublf(a, b)  (spu_sub((a), (b)))
+  #define  simdia_vsubi(a, b)  (spu_sub((a), (b)))
+  #define  simdia_vsubf(a, b)  (spu_sub((a), (b)))
+  #define simdia_vsublf(a, b)  (spu_sub((a), (b)))
 
   /***** Multiplication *****/
-  #define   vmulf(a, b)  (spu_mul((a), (b)))
-  #define  vmullf(a, b)  (spu_mul((a), (b)))
+  #define   simdia_vmulf(a, b)  (spu_mul((a), (b)))
+  #define  simdia_vmullf(a, b)  (spu_mul((a), (b)))
 
   /***** Division *****/
-  #define vdivf(a, b)  (spu_mul((a), spu_re(b)))
-  inline veclf vdivlf(const veclf a, const veclf b) { veclf r = { 0.0, 0.0 }; spu_insert((spu_extract(a, 0) / spu_extract(b, 0)), r, 0); spu_insert((spu_extract(a, 1) / spu_extract(b, 1)), r, 1); return r; }
+  #define simdia_vdivf(a, b)  (spu_mul((a), spu_re(b)))
+  inline simdia_veclf simdia_vdivlf(const simdia_veclf a, const simdia_veclf b) { simdia_veclf r = { 0.0, 0.0 }; spu_insert((spu_extract(a, 0) / spu_extract(b, 0)), r, 0); spu_insert((spu_extract(a, 1) / spu_extract(b, 1)), r, 1); return r; }
 
   /***** Fused Multiply Add *****/
-  #define  vmaddf(a, b, c)  (spu_madd((a), (b), (c)))
-  #define vmaddlf(a, b, c)  (spu_madd((a), (b), (c)))
+  #define  simdia_vmaddf(a, b, c)  (spu_madd((a), (b), (c)))
+  #define simdia_vmaddlf(a, b, c)  (spu_madd((a), (b), (c)))
 
   /***** Reciprocal *****/
-  #define  vrecipf(a)  (spu_re(a))
-  inline veclf vreciplf(const veclf a, const veclf b) { veclf r = { 0.0, 0.0 }; spu_insert((1.0f / spu_extract(a, 0)), r, 0); spu_insert((1.0f / spu_extract(a, 1)), r, 1); return r; }
+  #define  simdia_vrecipf(a)  (spu_re(a))
+  inline simdia_veclf simdia_vreciplf(const simdia_veclf a, const simdia_veclf b) { simdia_veclf r = { 0.0, 0.0 }; spu_insert((1.0f / spu_extract(a, 0)), r, 0); spu_insert((1.0f / spu_extract(a, 1)), r, 1); return r; }
 
   /***** Square Root *****/
-  #define vsqrtf(a) (spu_re(spu_rsqrte(a)))
-  inline veclf vsqrtlf(const veclf a, const veclf b) { veclf r = { 0.0, 0.0 }; spu_insert(sqrt(spu_extract(a, 0)), r, 0); spu_insert(sqrt(spu_extract(a, 1)), r, 1); return r; }
+  #define simdia_vsqrtf(a) (spu_re(spu_rsqrte(a)))
+  inline simdia_veclf simdia_vsqrtlf(const simdia_veclf a, const simdia_veclf b) { simdia_veclf r = { 0.0, 0.0 }; spu_insert(sqrt(spu_extract(a, 0)), r, 0); spu_insert(sqrt(spu_extract(a, 1)), r, 1); return r; }
 
   /***** Reciprocal Square Root *****/
-  #define vrsqrtf(a) (spu_rsqrte(a))
-  inline veclf vrsqrtlf(const veclf a, const veclf b) { veclf r = { 0.0, 0.0 }; spu_insert((1.0f / sqrt(spu_extract(a, 0))), r, 0); spu_insert((1.0f / sqrt(spu_extract(a, 1))), r, 1); return r; }
+  #define simdia_vrsqrtf(a) (spu_rsqrte(a))
+  inline simdia_veclf simdia_vrsqrtlf(const simdia_veclf a, const simdia_veclf b) { simdia_veclf r = { 0.0, 0.0 }; spu_insert((1.0f / sqrt(spu_extract(a, 0))), r, 0); spu_insert((1.0f / sqrt(spu_extract(a, 1))), r, 1); return r; }
 
   /***** Not *****/
-  #define  vnoti(a)  (spu_nor((a), const_vzeroi))
-  #define  vnotf(a)  (spu_nor((a), const_vzerof))
-  #define vnotlf(a)  (spu_nor((a), const_vzerolf))
+  #define  simdia_vnoti(a)  (spu_nor((a), (a)))
+  #define  simdia_vnotf(a)  (spu_nor((a), (a)))
+  #define simdia_vnotlf(a)  (spu_nor((a), (a)))
 
   /***** Or *****/
-  #define  vori(a, b)  (spu_or((a), (b)))
-  #define  vorf(a, b)  (spu_or((a), (b)))
-  #define vorlf(a, b)  (spu_or((a), (b)))
+  #define  simdia_vori(a, b)  (spu_or((a), (b)))
+  #define  simdia_vorf(a, b)  (spu_or((a), (b)))
+  #define simdia_vorlf(a, b)  (spu_or((a), (b)))
 
   /***** Nor *****/
-  #define  vnori(a, b)  (spu_nor((a), (b)))
-  #define  vnorf(a, b)  (spu_nor((a), (b)))
-  #define vnorlf(a, b)  (spu_nor((a), (b)))
+  #define  simdia_vnori(a, b)  (spu_nor((a), (b)))
+  #define  simdia_vnorf(a, b)  (spu_nor((a), (b)))
+  #define simdia_vnorlf(a, b)  (spu_nor((a), (b)))
 
   /***** And *****/
-  #define  vandi(a, b)  (spu_and((a), (b)))
-  #define  vandf(a, b)  (spu_and((a), (b)))
-  #define vandlf(a, b)  (spu_and((a), (b)))
+  #define  simdia_vandi(a, b)  (spu_and((a), (b)))
+  #define  simdia_vandf(a, b)  (spu_and((a), (b)))
+  #define simdia_vandlf(a, b)  (spu_and((a), (b)))
 
   /***** Nand *****/
-  #define  vnandi(a, b)  (spu_nand((a), (b)))
-  #define  vnandf(a, b)  (spu_nand((a), (b)))
-  #define vnandlf(a, b)  (spu_nand((a), (b)))
+  #define  simdia_vnandi(a, b)  (spu_nand((a), (b)))
+  #define  simdia_vnandf(a, b)  (spu_nand((a), (b)))
+  #define simdia_vnandlf(a, b)  (spu_nand((a), (b)))
 
   /***** Xor *****/
-  #define  vxori(a, b)  (spu_xor((a), (b)))
-  #define  vxorf(a, b)  (spu_xor((a), (b)))
-  #define vxorlf(a, b)  (spu_xor((a), (b)))
+  #define  simdia_vxori(a, b)  (spu_xor((a), (b)))
+  #define  simdia_vxorf(a, b)  (spu_xor((a), (b)))
+  #define simdia_vxorlf(a, b)  (spu_xor((a), (b)))
 
   /***** Nxor *****/
-  #define  vnxori(a, b)  ( vnoti( vxori((a), (b))))
-  #define  vnxorf(a, b)  ( vnotf( vxorf((a), (b))))
-  #define vnxorlf(a, b)  (vnotlf(vxorlf((a), (b))))
+  #define  simdia_vnxori(a, b)  ( simdia_vnoti( simdia_vxori((a), (b))))
+  #define  simdia_vnxorf(a, b)  ( simdia_vnotf( simdia_vxorf((a), (b))))
+  #define simdia_vnxorlf(a, b)  (simdia_vnotlf(simdia_vxorlf((a), (b))))
 
   /***** Equal To *****/
-  #define  vcmpeqi(a, b)  ((veci)(spu_cmpeq((a), (b))))
-  #define  vcmpeqf(a, b)  ((veci)(spu_cmpeq((a), (b))))
-  #define vcmpeqlf(a, b)  ((veci)(spu_cmpeq((a), (b))))
+  #define  simdia_vcmpeqi(a, b)  ((simdia_veci)(spu_cmpeq((a), (b))))
+  #define  simdia_vcmpeqf(a, b)  ((simdia_veci)(spu_cmpeq((a), (b))))
+  #define simdia_vcmpeqlf(a, b)  ((simdia_veci)(spu_cmpeq((a), (b))))
 
   /***** Greater Than *****/
-  #define  vcmpgti(a, b)  ((veci)(spu_cmpgt((a), (b))))
-  #define  vcmpgtf(a, b)  ((veci)(spu_cmpgt((a), (b))))
-  #define vcmpgtlf(a, b)  ((veci)(spu_cmpgt((a), (b))))
+  #define  simdia_vcmpgti(a, b)  ((simdia_veci)(spu_cmpgt((a), (b))))
+  #define  simdia_vcmpgtf(a, b)  ((simdia_veci)(spu_cmpgt((a), (b))))
+  #define simdia_vcmpgtlf(a, b)  ((simdia_veci)(spu_cmpgt((a), (b))))
 
   // NOTE : Try to create versions of >= and < that do not double evaluate their inputs
 
   /***** Greater Than or Equal To *****/
-  #define  vcmpgei(a, b)  (spu_or( vcmpeqi((a), (b)),  vcmpgti((a), (b))))
-  #define  vcmpgef(a, b)  (spu_or( vcmpeqf((a), (b)),  vcmpgtf((a), (b))))
-  #define vcmpgelf(a, b)  (spu_or(vcmpeqlf((a), (b)), vcmpgtlf((a), (b))))
+  #define  simdia_vcmpgei(a, b)  (spu_or( simdia_vcmpeqi((a), (b)),  simdia_vcmpgti((a), (b))))
+  #define  simdia_vcmpgef(a, b)  (spu_or( simdia_vcmpeqf((a), (b)),  simdia_vcmpgtf((a), (b))))
+  #define simdia_vcmpgelf(a, b)  (spu_or(simdia_vcmpeqlf((a), (b)), simdia_vcmpgtlf((a), (b))))
 
   /***** Less Than *****/
-  #define  vcmplti(a, b)  (spu_nor( vcmpgti((a), (b)),  vcmpeqi((a), (b))))
-  #define  vcmpltf(a, b)  (spu_nor( vcmpgtf((a), (b)),  vcmpeqf((a), (b))))
-  #define vcmpltlf(a, b)  (spu_nor(vcmpgtlf((a), (b)), vcmpeqlf((a), (b))))
+  #define  simdia_vcmplti(a, b)  (spu_nor( simdia_vcmpgti((a), (b)),  simdia_vcmpeqi((a), (b))))
+  #define  simdia_vcmpltf(a, b)  (spu_nor( simdia_vcmpgtf((a), (b)),  simdia_vcmpeqf((a), (b))))
+  #define simdia_vcmpltlf(a, b)  (spu_nor(simdia_vcmpgtlf((a), (b)), simdia_vcmpeqlf((a), (b))))
 
   /***** Less Than or Equal To *****/
-  #define  vcmplei(a, b)  (spu_nor( vcmpgti((a), (b)),  const_vzeroi))
-  #define  vcmplef(a, b)  (spu_nor( vcmpgtf((a), (b)),  const_vzerof))
-  #define vcmplelf(a, b)  (spu_nor(vcmpgtlf((a), (b)), const_vzerolf))
+  #define  simdia_vcmplei(a, b)  (spu_nor( simdia_vcmpgti((a), (b)),  simdia_const_vzeroi))
+  #define  simdia_vcmplef(a, b)  (spu_nor( simdia_vcmpgtf((a), (b)),  simdia_const_vzerof))
+  #define simdia_vcmplelf(a, b)  (spu_nor(simdia_vcmpgtlf((a), (b)), simdia_const_vzerolf))
 
 
 /*******************************************************************************
@@ -653,295 +639,301 @@ inline veclf vreciplf(const veclf a) { veclf r; double* a_ptr =  (double*)(&a);
  ***** AltiVec
  *******************************************************************************
  *******************************************************************************/
-#elif defined(__VEC__) && (!(FORCE_NO_ALTIVEC))
+#elif defined(__VEC__) && (!(SIMDIA_FORCE_NO_ALTIVEC))
 
   /***** Data Types *****/
-  typedef vector signed int veci;
-  typedef vector float vecf;
-#ifdef _ARCH_PWR7
-/** power 7 VSX supports 64 bit operands, it also includes VMX support
- * which means that things like vec_div, vec_insert, etcetera work for
- * ints floats and doubles.  These intrinsics also require a suitably
- * new version of the compiler on Power 7.  If you are somehow using a
- * Power 7 with an old compiler, please do not hesitate to open a can
- * of whoopass on whoever installed the tool chain, because that kind
- * of stupidity should not be tolerated.
- */
-  typedef vector double  veclf;
-#else
-  typedef __veclf veclf;
-#endif
+  typedef vector signed int simdia_veci;
+  typedef vector float      simdia_vecf;
+  #ifdef _ARCH_PWR7
+    /** power 7 VSX supports 64 bit operands, it also includes VMX support
+     * which means that things like vec_div, vec_insert, etcetera work for
+     * ints floats and doubles.  These intrinsics also require a suitably
+     * new version of the compiler on Power 7.  If you are somehow using a
+     * Power 7 with an old compiler, please do not hesitate to open a can
+     * of whoopass on whoever installed the tool chain, because that kind
+     * of stupidity should not be tolerated.
+     */ 
+    typedef vector double  simdia_veclf;
+  #else
+    typedef __simdia_veclf simdia_veclf;
+  #endif
 
   /***** Insert *****/
   /* TODO | FIXME - Try to make these functions not reference memory
      so values stay in registers */
+  #ifdef _ARCH_PWR7 
+    // swap argument order
+    #define  simdia_vinserti(a, b, c)  (vec_insert((b)), ((a)), ((c)))
+    #define  simdia_vinsertf(a, b, c)  (vec_insert((b)), ((a)), ((c)))
+    #define  simdia_vinsertlf(a, b, c)  (vec_insert((b)), ((a)), ((c)))
+  #else
+    inline  simdia_veci  simdia_vinserti( simdia_veci v, const    int s, const int i) {  simdia_veci r = v;    int* rPtr = (   int*)(&r); rPtr[i] = s; return r; }
+    inline  simdia_vecf  simdia_vinsertf( simdia_vecf v, const  float s, const int i) {  simdia_vecf r = v;  float* rPtr = ( float*)(&r); rPtr[i] = s; return r; }
+    #define simdia_vinsertlf __simdia_vinsertlf
+  #endif
 
-
-#ifdef _ARCH_PWR7 
-// swap argument order
- #define  vinserti(a, b, c)  (vec_insert((b)), ((a)), ((c)))
- #define  vinsertf(a, b, c)  (vec_insert((b)), ((a)), ((c)))
- #define  vinsertlf(a, b, c)  (vec_insert((b)), ((a)), ((c)))
-#else
-  inline  veci  vec_inserti( veci v, const    int s, const int i) {  veci r = v;    int* rPtr = (   int*)(&r); rPtr[i] = s; return r; }
-  inline  vecf  vinsertf( vecf v, const  float s, const int i) {  vecf r = v;  float* rPtr = ( float*)(&r); rPtr[i] = s; return r; }
-  inline veclf vinsertlf(veclf v, const double s, const int i) { return vec_insert(s,v,i); }
-
-#endif
   /***** Extract *****/
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vextracti(a, b)  (vec_extract((a), (b)))
+    #define  simdia_vextractf(a, b)  (vec_extract((a), (b)))
+    #define  simdia_vextractlf(a, b)  (vec_extract((a), (b)))
+  #else
+    /* TODO | FIXME - Try to make these functions not reference memory so values stay in registers */
+    inline    int  simdia_vextracti( simdia_veci v, const int i) {    int* vPtr = (   int*)(&v); return vPtr[i]; }
+    inline  float  simdia_vextractf( simdia_vecf v, const int i) {  float* vPtr = ( float*)(&v); return vPtr[i]; }
+    #define simdia_vextractlf __simdia_vextractlf
+  #endif
 
-#ifdef _ARCH_PWR7 
-#define  vextracti(a, b)  (vec_extract((a), (b)))
-#define  vextractf(a, b)  (vec_extract((a), (b)))
-#define  vextractlf(a, b)  (vec_extract((a), (b)))
-#else
-  /* TODO | FIXME - Try to make these functions not reference memory so values stay in registers */
-  inline    int  vextracti( veci v, const int i) {    int* vPtr = (   int*)(&v); return vPtr[i]; }
-  inline  float  vextractf( vecf v, const int i) {  float* vPtr = ( float*)(&v); return vPtr[i]; }
-
-  inline double vextractlf(veclf v, const int i) { double* vPtr = (double*)(&v); return vPtr[i]; }
-#endif
-  /***** Set *****/
-#ifdef _ARCH_PWR7 
   /***** Set *****/
-#define  vseti(a)  (vec_promote((a), 0))
-#define  vsetf(a)  (vec_promote((a), 0))
-#define  vsetlf(a)  (vec_promote((a), 0))
-#else
-  /* TODO : FIXME - There must be a better way to do this, but it
-  seems the only way to convert scalar to vector is to go through
-  memory instructions.  
-
-  EJB: converting between scalar and vector is the sort of thing you
-  want to avoid doing on altivec.  Better to rethink and find a way to
-  stay in the vector engine if at all possible.
-
-   */
-  inline veci vseti(const   int a) { __veci r; r.v0 = a; return vec_splat(*((veci*)(&r)), 0); }
-  inline vecf vsetf(const float a) { __vecf r; r.v0 = a; return vec_splat(*((vecf*)(&r)), 0); }
-  #define vsetlf __vsetlf
-#endif
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vseti(a)  (vec_promote((a), 0))
+    #define  simdia_vsetf(a)  (vec_promote((a), 0))
+    #define  simdia_vsetlf(a)  (vec_promote((a), 0))
+  #else
+    /* TODO : FIXME - There must be a better way to do this, but it
+    seems the only way to convert scalar to vector is to go through
+    memory instructions.  
+
+    EJB: converting between scalar and vector is the sort of thing you
+    want to avoid doing on altivec.  Better to rethink and find a way to
+    stay in the vector engine if at all possible.
+    */
+
+    inline simdia_veci simdia_vseti(const   int a) { __simdia_veci r; r.v0 = a; return vec_splat(*((simdia_veci*)(&r)), 0); }
+    inline simdia_vecf simdia_vsetf(const float a) { __simdia_vecf r; r.v0 = a; return vec_splat(*((simdia_vecf*)(&r)), 0); }
+    #define simdia_vsetlf __simdia_vsetlf
+  #endif
   /* NOTE: Declare one for unsigned char vector also (required by rotate functions) */
-  inline vector unsigned char vset16uc(const unsigned char c) { vector unsigned char r __attribute__((aligned(16))); ((unsigned char*)(&r))[0] = c; return vec_splat(r, 0); }
+  inline vector unsigned char simdia_vset16uc(const unsigned char c) { vector unsigned char r __attribute__((aligned(16))); ((unsigned char*)(&r))[0] = c; return vec_splat(r, 0); }
 
   /***** Constant Zero *****/
-  #define  const_vzeroi  (vec_splat_s32(0))
-  #define  const_vzerof  (vec_ctf(vec_splat_s32(0), 0))
-#ifdef _ARCH_PWR7 
-  #define const_vzerolf  (vec_splats(0))
-#else
-  #define const_vzerolf  (__const_vzerolf)
-#endif
+  #define  simdia_const_vzeroi  (vec_splat_s32(0))
+  #define  simdia_const_vzerof  (vec_ctf(vec_splat_s32(0), 0))
+  #ifdef _ARCH_PWR7 
+    #define simdia_const_vzerolf  (vec_splats(0))
+  #else
+    #define simdia_const_vzerolf  (__simdia_const_vzerolf)
+  #endif
+
   /***** Constant One *****/
-  #define  const_vonei  (vec_splat_s32(1))
-  #define  const_vonef  (vec_ctf(vec_splat_s32(1), 0))
-#ifdef _ARCH_PWR7 
-  #define const_vonelf  (vec_splats(1))
-#else
-  #define const_vonelf  (__const_vonelf)
-#endif
+  #define  simdia_const_vonei  (vec_splat_s32(1))
+  #define  simdia_const_vonef  (vec_ctf(vec_splat_s32(1), 0))
+  #ifdef _ARCH_PWR7 
+    #define simdia_const_vonelf  (vec_splats(1))
+  #else
+    #define simdia_const_vonelf  (__simdia_const_vonelf)
+  #endif
 
   /***** Constant Two *****/
-  #define  const_vtwoi  (vec_splat_s32(2))
-  #define  const_vtwof  (vec_ctf(vec_splat_s32(2), 0))
-#ifdef _ARCH_PWR7 
-  #define const_vtwolf  (vec_splats(2))
-#else
-  #define const_vtwolf  (__const_vtwolf)
-#endif
+  #define  simdia_const_vtwoi  (vec_splat_s32(2))
+  #define  simdia_const_vtwof  (vec_ctf(vec_splat_s32(2), 0))
+  #ifdef _ARCH_PWR7 
+    #define simdia_const_vtwolf  (vec_splats(2))
+  #else
+    #define simdia_const_vtwolf  (__simdia_const_vtwolf)
+  #endif
+
   /***** Constant Negative One *****/
-  #define  const_vnegonei  (vec_splat_s32(-1))
-  #define  const_vnegonef  (vec_ctf(vec_splat_s32(-1), 0))
-#ifdef _ARCH_PWR7 
-  #define const_vnegonelf  (vec_splats(-1))
-#else
-  #define const_vnegonelf  (__const_veclf)
-#endif
+  #define  simdia_const_vnegonei  (vec_splat_s32(-1))
+  #define  simdia_const_vnegonef  (vec_ctf(vec_splat_s32(-1), 0))
+  #ifdef _ARCH_PWR7 
+    #define simdia_const_vnegonelf  (vec_splats(-1))
+  #else
+    #define simdia_const_vnegonelf  (__const_veclf)
+  #endif
+
   /***** Rotate *****/
-  #define __vrotlbytes(a, s)  (vec_or(vec_slo((a), vset16uc(((s) & 0xf) << 3)), vec_sro((a), set16uc((16 - ((s) & 0xf)) << 3))))
-  #define __vrotrbytes(a, s)  (vec_or(vec_sro((a), vset16uc(((s) & 0xf) << 3)), vec_slo((a), set16uc((16 - ((s) & 0xf)) << 3))))
-  #define  vrotli(a, s)  __vrotlbytes((a), ((s) << 2))
-  #define  vrotlf(a, s)  __vrotlbytes((a), ((s) << 2))
-  #define vrotllf(a, s)  __vrotlbytes((a), ((s) << 3))
-  #define  vrothi(a, s)  __vrotrbytes((a), ((s) << 2))
-  #define  vrothf(a, s)  __vrotrbytes((a), ((s) << 2))
-  #define vrothlf(a, s)  __vrotrbytes((a), ((s) << 3))
+  #define __simdia_vrotlbytes(a, s)  (vec_or(vec_slo((a), simdia_vset16uc(((s) & 0xf) << 3)), vec_sro((a), simdia_set16uc((16 - ((s) & 0xf)) << 3))))
+  #define __simdia_vrotrbytes(a, s)  (vec_or(vec_sro((a), simdia_vset16uc(((s) & 0xf) << 3)), vec_slo((a), simdia_set16uc((16 - ((s) & 0xf)) << 3))))
+  #define  simdia_vrotli(a, s)  __simdia_vrotlbytes((a), ((s) << 2))
+  #define  simdia_vrotlf(a, s)  __simdia_vrotlbytes((a), ((s) << 2))
+  #define simdia_vrotllf(a, s)  __simdia_vrotlbytes((a), ((s) << 3))
+  #define  simdia_vrothi(a, s)  __simdia_vrotrbytes((a), ((s) << 2))
+  #define  simdia_vrothf(a, s)  __simdia_vrotrbytes((a), ((s) << 2))
+  #define simdia_vrothlf(a, s)  __simdia_vrotrbytes((a), ((s) << 3))
 
   /***** Addition *****/
-  #define  vaddi(a, b)  (vec_add((a), (b)))
-  #define  vaddf(a, b)  (vec_add((a), (b)))
-#ifdef _ARCH_PWR7 
-  #define  vaddlf(a, b)  (vec_add((a), (b)))
-#else
-  #define vaddlf __vaddlf
-#endif
+  #define  simdia_vaddi(a, b)  (vec_add((a), (b)))
+  #define  simdia_vaddf(a, b)  (vec_add((a), (b)))
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vaddlf(a, b)  (vec_add((a), (b)))
+  #else
+    #define simdia_vaddlf __simdia_vaddlf
+  #endif
+
   /***** Subtraction *****/
-  #define  vsubi(a, b)  (vec_sub((a), (b)))
-  #define  vsubf(a, b)  (vec_sub((a), (b)))
-#ifdef _ARCH_PWR7 
-  #define  vsublf(a, b)  (vec_sub((a), (b)))
-#else
-  #define vsublf __vsublf
-#endif
-  /***** Multiplication *****/
+  #define  simdia_vsubi(a, b)  (vec_sub((a), (b)))
+  #define  simdia_vsubf(a, b)  (vec_sub((a), (b)))
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vsublf(a, b)  (vec_sub((a), (b)))
+  #else
+    #define simdia_vsublf __simdia_vsublf
+  #endif
 
-// NOTE: Try to find a way to do this without double evaluating a
+  /***** Multiplication *****/
+  // NOTE: Try to find a way to do this without double evaluating a
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vmulf(a, b)  (vec_mul((a), (b)))
+    #define  simdia_vmullf(a, b)  (vec_mul((a), (b)))
+  #else
+    #define  simdia_vmulf(a, b)  (vec_madd((a), (b), vec_xor((a), (a))))
+    #define  simdia_vmullf __simdia_vmullf
+  #endif
 
-#ifdef _ARCH_PWR7 
-#define  vmulf(a, b)  (vec_mul((a), (b)))
-  #define  vmullf(a, b)  (vec_mul((a), (b)))
-#else
-  #define  vmulf(a, b)  (vec_madd((a), (b), vec_xor((a), (a))))
-  #define vmullf __vmullf
-#endif
   /***** Division *****/
-#ifdef _ARCH_PWR7 
-  #define vdivf(a, b)  (vec_div((a)), ((b)))
-  #define vdivlf(a, b)  (vec_div((a)), ((b)))
-#else
-  #define vdivf(a, b)  (vmulf((a), vec_re(b)))
-  #define vdivlf __vdivlf
-#endif
+  #ifdef _ARCH_PWR7 
+    #define simdia_vdivf(a, b)  (vec_div((a)), ((b)))
+    #define simdia_vdivlf(a, b)  (vec_div((a)), ((b)))
+  #else
+    #define simdia_vdivf(a, b)  (simdia_vmulf((a), vec_re(b)))
+    #define simdia_vdivlf __simdia_vdivlf
+  #endif
 
   /***** Fused Multiply Add *****/
-  #define vmaddf(a, b, c)  (vec_madd((a), (b), (c)))
-#ifdef _ARCH_PWR7 
-  #define vmaddlf(a, b, c)  (vec_madd((a), (b), (c)))
-#else
-  #define vmaddlf __vmaddlf
-#endif
+  #define simdia_vmaddf(a, b, c)  (vec_madd((a), (b), (c)))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vmaddlf(a, b, c)  (vec_madd((a), (b), (c)))
+  #else
+    #define simdia_vmaddlf __simdia_vmaddlf
+  #endif
 
   /***** Reciprocal *****/
-  #define vrecipf(a)  (vec_re(a))
-#ifdef _ARCH_PWR7 
-  #define vreciplf(a)  (vec_re(a))
-#else
-  #define vreciplf __vreciplf
-#endif
+  #define simdia_vrecipf(a)  (vec_re(a))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vreciplf(a)  (vec_re(a))
+  #else
+    #define simdia_vreciplf __simdia_vreciplf
+  #endif
+
   /***** Square Root *****/
-  #define vsqrtf(a)  (vec_re(vec_rsqrte(a)))
-#ifdef _ARCH_PWR7 
-#define vsqrtlf(a)  (vec_sqrt(a))
-#else
-  #define vsqrtlf __vsqrtlf
-#endif
+  #define simdia_vsqrtf(a)  (vec_re(vec_rsqrte(a)))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vsqrtlf(a)  (vec_sqrt(a))
+  #else
+    #define simdia_vsqrtlf __simdia_vsqrtlf
+  #endif
+
   /***** Reciprocal Square Root *****/
-  #define vrsqrtf(a)  (vec_rsqrte(a))
-#ifdef _ARCH_PWR7 
-  #define vrsqrtlf(a)  (vec_rsqrte(a))
-#else
-  #define vrsqrtlf __vrsqrtlf
-#endif
+  #define simdia_vrsqrtf(a)  (vec_rsqrte(a))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vrsqrtlf(a)  (vec_rsqrte(a))
+  #else
+    #define simdia_vrsqrtlf __simdia_vrsqrtlf
+  #endif
 
   /***** Not *****/
-
-
-#ifdef _ARCH_PWR7 
-  #define vnoti(a)  (vec_neg(a))
-  #define vnotf(a)  (vec_neg(a))
-  #define vnotlf(a)  (vec_neg(a))
-#else
-  #define vnoti(a)  (vec_xor((a), const_vnegonei))
-  #define vnotf(a)  (vec_xor((a), const_vnegonei))
-  #define vnotlf __vnotlf
-#endif
+  #ifdef _ARCH_PWR7 
+    #define simdia_vnoti(a)  (vec_neg(a))
+    #define simdia_vnotf(a)  (vec_neg(a))
+    #define simdia_vnotlf(a)  (vec_neg(a))
+  #else
+    #define simdia_vnoti(a)  (vec_xor((a), simdia_const_vnegonei))
+    #define simdia_vnotf(a)  (vec_xor((a), simdia_const_vnegonei))
+    #define simdia_vnotlf __simdia_vnotlf
+  #endif
 
   /***** Or *****/
-  #define vori(a, b)  (vec_or((a), (b)))
-  #define vorf(a, b)  (vec_or((a), (b)))
-#ifdef _ARCH_PWR7 
-  #define vorlf(a, b)  (vec_or((a), (b)))
-#else
-  #define vorlf __vorlf
-#endif
+  #define simdia_vori(a, b)  (vec_or((a), (b)))
+  #define simdia_vorf(a, b)  (vec_or((a), (b)))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vorlf(a, b)  (vec_or((a), (b)))
+  #else
+    #define simdia_vorlf __simdia_vorlf
+  #endif
 
   /***** Nor *****/
-  #define vnori(a, b)  (vec_nor((a), (b)))
-  #define vnorf(a, b)  (vec_nor((a), (b)))
-#ifdef _ARCH_PWR7 
-  #define vnorlf(a, b)  (vec_nor((a), (b)))
-#else
-  #define vnorlf __vnorlf
-#endif
+  #define simdia_vnori(a, b)  (vec_nor((a), (b)))
+  #define simdia_vnorf(a, b)  (vec_nor((a), (b)))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vnorlf(a, b)  (vec_nor((a), (b)))
+  #else
+    #define simdia_vnorlf __simdia_vnorlf
+  #endif
+
   /***** And *****/
-  #define vandi(a, b)  (vec_and((a), (b)))
-  #define vandf(a, b)  (vec_and((a), (b)))
-#ifdef _ARCH_PWR7 
-  #define vandlf(a, b)  (vec_and((a), (b)))
-#else
-  #define vandlf __vandlf
-#endif
+  #define simdia_vandi(a, b)  (vec_and((a), (b)))
+  #define simdia_vandf(a, b)  (vec_and((a), (b)))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vandlf(a, b)  (vec_and((a), (b)))
+  #else
+    #define simdia_vandlf __simdia_vandlf
+  #endif
+
   /***** Nand *****/
-  #define vnandi(a, b)  (vnoti(vandi((a), (b))))
-  #define vnandf(a, b)  (vnotf(vandf((a), (b))))
-#ifdef _ARCH_PWR7 
-  #define vnandlf(a, b)  (vnotf(vandf((a), (b))))
-#else
-  #define vnandlf __vnandlf
-#endif
+  #define simdia_vnandi(a, b)  (simdia_vnoti(simdia_vandi((a), (b))))
+  #define simdia_vnandf(a, b)  (simdia_vnotf(simdia_vandf((a), (b))))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vnandlf(a, b)  (simdia_vnotf(simdia_vandf((a), (b))))
+  #else
+    #define simdia_vnandlf __simdia_vnandlf
+  #endif
+
   /***** Xor *****/
-  #define vxori(a, b)  (vec_xor((a), (b)))
-  #define vxorf(a, b)  (vec_xor((a), (b)))
-#ifdef _ARCH_PWR7 
-  #define vxorlf(a, b)  (vec_xor((a), (b)))
-#else
-  #define vxorlf __vxorlf
-#endif
+  #define simdia_vxori(a, b)  (vec_xor((a), (b)))
+  #define simdia_vxorf(a, b)  (vec_xor((a), (b)))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vxorlf(a, b)  (vec_xor((a), (b)))
+  #else
+    #define simdia_vxorlf __simdia_vxorlf
+  #endif
 
   /***** Nxor *****/
-  #define vnxori(a, b)  (vnoti(vxori((a), (b))))
-  #define vnxorf(a, b)  (vnotf(vxorf((a), (b))))
-#ifdef _ARCH_PWR7 
-  #define vnxorlf(a, b)  (vnotlf(vxorf((a), (b))))
-#else
-  #define vnxorlf __vnxorlf
-#endif
+  #define simdia_vnxori(a, b)  (simdia_vnoti(simdia_vxori((a), (b))))
+  #define simdia_vnxorf(a, b)  (simdia_vnotf(simdia_vxorf((a), (b))))
+  #ifdef _ARCH_PWR7 
+    #define simdia_vnxorlf(a, b)  (simdia_vnotlf(simdia_vxorf((a), (b))))
+  #else
+    #define simdia_vnxorlf __simdia_vnxorlf
+  #endif
+
   /***** Equal To *****/
-  #define  vcmpeqi(a, b)  ((veci)(vec_cmpeq((a), (b))))
-  #define  vcmpeqf(a, b)  ((veci)(vec_cmpeq((a), (b))))
-#ifdef _ARCH_PWR7 
-  #define  vcmpeqlf(a, b)  ((veci)(vec_cmpeq((a), (b))))
-#else
-  #define vcmpeqlf __vcmpeqlf
-#endif
+  #define  simdia_vcmpeqi(a, b)  ((simdia_veci)(vec_cmpeq((a), (b))))
+  #define  simdia_vcmpeqf(a, b)  ((simdia_veci)(vec_cmpeq((a), (b))))
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vcmpeqlf(a, b)  ((simdia_veci)(vec_cmpeq((a), (b))))
+  #else
+    #define simdia_vcmpeqlf __simdia_vcmpeqlf
+  #endif
+
   /***** Greater Than *****/
-  #define  vcmpgti(a, b)  ((veci)(vec_cmpgt((a), (b))))
-  #define  vcmpgtf(a, b)  ((veci)(vec_cmpgt((a), (b))))
-#ifdef _ARCH_PWR7 
-  #define  vcmpgtlf(a, b)  ((veci)(vec_cmpgt((a), (b))))
-#else
-  #define vcmpgtlf __vcmpgtlf
-#endif
+  #define  simdia_vcmpgti(a, b)  ((simdia_veci)(vec_cmpgt((a), (b))))
+  #define  simdia_vcmpgtf(a, b)  ((simdia_veci)(vec_cmpgt((a), (b))))
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vcmpgtlf(a, b)  ((simdia_veci)(vec_cmpgt((a), (b))))
+  #else
+    #define simdia_vcmpgtlf __simdia_vcmpgtlf
+  #endif
 
   /***** Greater Than Or Equal To *****/
-  #define  vcmpgei(a, b)  ((veci)(vec_cmpge((a), (b))))
-  #define  vcmpgef(a, b)  ((veci)(vec_cmpge((a), (b))))
-#ifdef _ARCH_PWR7 
-  #define  vcmpgelf(a, b)  ((veci)(vec_cmpge((a), (b))))
-#else
-  #define vcmpgelf __vcmpgelf
-#endif
+  #define  simdia_vcmpgei(a, b)  ((simdia_veci)(vec_cmpge((a), (b))))
+  #define  simdia_vcmpgef(a, b)  ((simdia_veci)(vec_cmpge((a), (b))))
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vcmpgelf(a, b)  ((simdia_veci)(vec_cmpge((a), (b))))
+  #else
+    #define simdia_vcmpgelf __simdia_vcmpgelf
+  #endif
 
   /***** Less Than *****/
-  #define  vcmplti(a, b)  ((veci)(vec_cmplt((a), (b))))
-  #define  vcmpltf(a, b)  ((veci)(vec_cmplt((a), (b))))
-#ifdef _ARCH_PWR7 
-  #define  vcmpltlf(a, b)  ((veci)(vec_cmplt((a), (b))))
-#else
-  #define vcmpltlf __vcmpltlf
-#endif
+  #define  simdia_vcmplti(a, b)  ((simdia_veci)(vec_cmplt((a), (b))))
+  #define  simdia_vcmpltf(a, b)  ((simdia_veci)(vec_cmplt((a), (b))))
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vcmpltlf(a, b)  ((simdia_veci)(vec_cmplt((a), (b))))
+  #else
+    #define simdia_vcmpltlf __simdia_vcmpltlf
+  #endif
 
   /***** Less Than Or Equal To *****/
-  #define  vcmplei(a, b)  ((veci)(vec_cmple((a), (b))))
-  #define  vcmplef(a, b)  ((veci)(vec_cmple((a), (b))))
-#ifdef _ARCH_PWR7 
-  #define  vcmplelf(a, b)  ((veci)(vec_cmple((a), (b))))
-// NOTE: vec_cmple not listed in Calin's wiki page of builtins for
-// PWR7, but has a header definition in the compiler
-#else
-  #define vcmplelf __vcmplelf
-#endif
+  #define  simdia_vcmplei(a, b)  ((simdia_veci)(vec_cmple((a), (b))))
+  #define  simdia_vcmplef(a, b)  ((simdia_veci)(vec_cmple((a), (b))))
+  #ifdef _ARCH_PWR7 
+    #define  simdia_vcmplelf(a, b)  ((simdia_veci)(vec_cmple((a), (b))))
+    // NOTE: vec_cmple not listed in Calin's wiki page of builtins for
+    // PWR7, but has a header definition in the compiler
+  #else
+    #define simdia_vcmplelf __simdia_vcmplelf
+  #endif
+
+
 /*******************************************************************************
  *******************************************************************************
  ***** Mapping to Generic C Implementation
@@ -950,146 +942,146 @@ inline veclf vreciplf(const veclf a) { veclf r; double* a_ptr =  (double*)(&a);
 #else
 
   /***** Data Types *****/
-  typedef   __veci   veci;
-  typedef   __vecf   vecf;
-  typedef  __veclf  veclf;
+  typedef   __simdia_veci   simdia_veci;
+  typedef   __simdia_vecf   simdia_vecf;
+  typedef  __simdia_veclf  simdia_veclf;
 
   /***** Insert *****/
-  #define  vinserti  __vinserti
-  #define  vinsertf  __vinsertf
-  #define vinsertlf __vinsertlf
+  #define  simdia_vinserti  __simdia_vinserti
+  #define  simdia_vinsertf  __simdia_vinsertf
+  #define simdia_vinsertlf __simdia_vinsertlf
 
   /***** Extract *****/
-  #define  vextracti  __vextracti
-  #define  vextractf  __vextractf
-  #define vextractlf __vextractlf
+  #define  simdia_vextracti  __simdia_vextracti
+  #define  simdia_vextractf  __simdia_vextractf
+  #define simdia_vextractlf __simdia_vextractlf
 
   /***** Set *****/
-  #define  vseti  __vseti
-  #define  vsetf  __vsetf
-  #define vsetlf __vsetlf
+  #define  simdia_vseti  __simdia_vseti
+  #define  simdia_vsetf  __simdia_vsetf
+  #define simdia_vsetlf __simdia_vsetlf
 
   /***** Constant Zero *****/
-  #define  const_vzeroi  __const_vzeroi
-  #define  const_vzerof  __const_vzerof
-  #define const_vzerolf __const_vzerolf
+  #define  simdia_const_vzeroi  __simdia_const_vzeroi
+  #define  simdia_const_vzerof  __simdia_const_vzerof
+  #define simdia_const_vzerolf __simdia_const_vzerolf
 
   /***** Constant One *****/
-  #define  const_vonei  __const_vonei
-  #define  const_vonef  __const_vonef
-  #define const_vonelf __const_vonelf
+  #define  simdia_const_vonei  __simdia_const_vonei
+  #define  simdia_const_vonef  __simdia_const_vonef
+  #define simdia_const_vonelf __simdia_const_vonelf
 
   /***** Constant Two *****/
-  #define  const_vtwoi  __const_vtwoi
-  #define  const_vtwof  __const_vtwof
-  #define const_vtwolf __const_vtwolf
+  #define  simdia_const_vtwoi  __simdia_const_vtwoi
+  #define  simdia_const_vtwof  __simdia_const_vtwof
+  #define simdia_const_vtwolf __simdia_const_vtwolf
 
   /***** Constant Negative One *****/
-  #define  const_vnegonei  __const_vnegonei
-  #define  const_vnegonef  __const_vnegonef
-  #define const_vnegonelf __const_vnegonelf
+  #define  simdia_const_vnegonei  __simdia_const_vnegonei
+  #define  simdia_const_vnegonef  __simdia_const_vnegonef
+  #define simdia_const_vnegonelf __simdia_const_vnegonelf
 
   /***** Rotate *****/
-  #define  vrothi  __vrothi
-  #define  vrothf  __vrothf
-  #define vrothlf __vrothlf
-  #define  vrotli  __vrotli
-  #define  vrotlf  __vrotlf
-  #define vrotllf __vrotllf
+  #define  simdia_vrothi  __simdia_vrothi
+  #define  simdia_vrothf  __simdia_vrothf
+  #define simdia_vrothlf __simdia_vrothlf
+  #define  simdia_vrotli  __simdia_vrotli
+  #define  simdia_vrotlf  __simdia_vrotlf
+  #define simdia_vrotllf __simdia_vrotllf
   
   /***** Addition *****/
-  #define  vaddi  __vaddi
-  #define  vaddf  __vaddf
-  #define vaddlf __vaddlf
+  #define  simdia_vaddi  __simdia_vaddi
+  #define  simdia_vaddf  __simdia_vaddf
+  #define simdia_vaddlf __simdia_vaddlf
 
   /***** Subtraction *****/
-  #define  vsubi  __vsubi
-