## Glas :## Re: [glas] policy of mapping expressions to backend |

**From:** Toon Knapen (*toon.knapen_at_[hidden]*)

**Date:** 2006-01-23 01:48:46

**Next message:**Karl Meerbergen: "[glas] assignment policy"**Previous message:**Andrew Lumsdaine: "Re: [glas] mapping expressions to backend"**In reply to:**Wolfgang Bangerth: "Re: [glas] mapping expressions to backend"**Next in thread:**Karl Meerbergen: "[glas] assignment policy"**Reply:**Karl Meerbergen: "[glas] assignment policy"

Thus in case the backend to be used is configurable, what policies

should we envision to dispatch expressions to backend?

Suppose we have a BLAS backend, the expression `y+=a*x` will logically

be dispatched to an axpy. But what about the expression `y+=a*x+w` ? Do

we evaluate it with BLAS in two step (`y+=w;y+=a*x`) or do we evaluate

it with the generic backend since there's no _direct_ match with the

BLAS backend.

So which policy should we provide (or both)?

1) Only dispatch to a backend if the whole expressions matches exactly

one expression that is implemented by the backend

2) or should we try to match the whole expression with one or multiple

expressions that are implemented by the backend and thus trying to use

the preferred backend as much as possible.

Policy 1 works fine if we assume that a backend is only good at

evaluating the expressions that it directly supports while policy 2

assumes that one backend is in all cases far superior to another.

On the other hand when using policy 1, the interface to the backend

could be extended with expressions that are not _directly_ implemented

by the backend in case we know that it is nevertheless very good at

evaluating specific expressions. E.g. suppose we now that `y+=a*x+w` is

best evaluated with BLAS in two steps (instead of evaluating the

expression using a generic algo), we might list this expression to be

directly supported by the BLAS backend and thus force the dispatch of

the expression to the BLAS backend. The BLAS backend will on its turn

dispatch it to two BLAS calls.

Wolfgang Bangerth wrote:

>>The first option is that the user asks glas to automatically try to

>>dispatch all expressions to a specific backend. If the backend does not

>>provide a corresponding function, the expression will be evaluated by

>>the fallback (which is the glas implementation itself for instance).

>>For instance: If the user wishes to use BLAS as backend, writing

>>'y+=a*x' will automatically result in a call to axpy.

>

>

> I can't imagine why someone would want to use different backends in the same

> program. I would therefore proposed to take option 1. The way this is

> typically done is to give a switch at configure time:

>

> ./configure --with-backend=blas

> ./configure --with-backend=generic

> etc

>

> W.

>

> -------------------------------------------------------------------------

> Wolfgang Bangerth email: bangerth_at_[hidden]

> www: http://www.math.tamu.edu/~bangerth/

>

> _______________________________________________

> glas mailing list

> glas_at_[hidden]

> http://lists.boost.org/mailman/listinfo.cgi/glas

>

**Next message:**Karl Meerbergen: "[glas] assignment policy"**Previous message:**Andrew Lumsdaine: "Re: [glas] mapping expressions to backend"**In reply to:**Wolfgang Bangerth: "Re: [glas] mapping expressions to backend"**Next in thread:**Karl Meerbergen: "[glas] assignment policy"**Reply:**Karl Meerbergen: "[glas] assignment policy"