ViennaCL - The Vienna Computing Library: viennacl/scheduler/execute_scalar_assign.hpp Source File

ViennaCL - The Vienna Computing Library 1.7.1 Free open-source GPU-accelerated linear algebra and solver library. |

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
execute_scalar_assign.hpp
Go to the documentation of this file.
1 #ifndef VIENNACL_SCHEDULER_EXECUTE_SCALAR_ASSIGN_HPP
2 #define VIENNACL_SCHEDULER_EXECUTE_SCALAR_ASSIGN_HPP
3
4 /* =========================================================================
5 Copyright (c) 2010-2016, Institute for Microelectronics,
6 Institute for Analysis and Scientific Computing,
7 TU Wien.
8 Portions of this software are copyright by UChicago Argonne, LLC.
9
10 -----------------
11 ViennaCL - The Vienna Computing Library
12 -----------------
13
14 Project Head: Karl Rupp rupp@iue.tuwien.ac.at
15
16 (A list of authors and contributors can be found in the manual)
17
18 License: MIT (X11), see file LICENSE in the base directory
19 ============================================================================= */
20
21
26 #include "viennacl/forwards.h"
27 #include "viennacl/scheduler/forwards.h"
28 #include "viennacl/scheduler/execute_vector_dispatcher.hpp"
29 #include "viennacl/scheduler/execute_util.hpp"
30
31 namespace viennacl
32 {
33 namespace scheduler
34 {
35
37 inline void execute_scalar_assign_composite(statement const & s, statement_node const & root_node)
38 {
39 statement_node const & leaf = s.array()[root_node.rhs.node_index];
40 viennacl::context ctx = detail::extract_context(root_node);
41
42 if (leaf.op.type == OPERATION_BINARY_INNER_PROD_TYPE) // alpha = inner_prod( (x), (y) ) with x, y being either vectors or expressions
43 {
44 assert(root_node.lhs.type_family == SCALAR_TYPE_FAMILY && bool("Inner product requires assignment to scalar type!"));
45
46 if ( leaf.lhs.type_family == VECTOR_TYPE_FAMILY
47 && leaf.rhs.type_family == VECTOR_TYPE_FAMILY)
48
49 {
50 detail::inner_prod_impl(leaf.lhs, leaf.rhs, root_node.lhs);
51 }
52 else if ( leaf.lhs.type_family == COMPOSITE_OPERATION_FAMILY // temporary for (x)
53 && leaf.rhs.type_family == VECTOR_TYPE_FAMILY)
54 {
55 statement_node new_root_x;
56
57 detail::new_element(new_root_x.lhs, leaf.rhs, ctx);
58
59 new_root_x.op.type_family = OPERATION_BINARY_TYPE_FAMILY;
60 new_root_x.op.type = OPERATION_BINARY_ASSIGN_TYPE;
61
62 new_root_x.rhs.type_family = COMPOSITE_OPERATION_FAMILY;
63 new_root_x.rhs.subtype = INVALID_SUBTYPE;
64 new_root_x.rhs.numeric_type = INVALID_NUMERIC_TYPE;
65 new_root_x.rhs.node_index = leaf.lhs.node_index;
66
67 // work on subexpression:
68 // TODO: Catch exception, free temporary, then rethrow
69 detail::execute_composite(s, new_root_x);
70
71 detail::inner_prod_impl(new_root_x.lhs, leaf.rhs, root_node.lhs);
72
73 detail::delete_element(new_root_x.lhs);
74 }
75 else if ( leaf.lhs.type_family == VECTOR_TYPE_FAMILY
76 && leaf.rhs.type_family == COMPOSITE_OPERATION_FAMILY) // temporary for (y)
77 {
78 statement_node new_root_y;
79
80 detail::new_element(new_root_y.lhs, leaf.lhs, ctx);
81
82 new_root_y.op.type_family = OPERATION_BINARY_TYPE_FAMILY;
83 new_root_y.op.type = OPERATION_BINARY_ASSIGN_TYPE;
84
85 new_root_y.rhs.type_family = COMPOSITE_OPERATION_FAMILY;
86 new_root_y.rhs.subtype = INVALID_SUBTYPE;
87 new_root_y.rhs.numeric_type = INVALID_NUMERIC_TYPE;
88 new_root_y.rhs.node_index = leaf.rhs.node_index;
89
90 // work on subexpression:
91 // TODO: Catch exception, free temporary, then rethrow
92 detail::execute_composite(s, new_root_y);
93
94 detail::inner_prod_impl(leaf.lhs, new_root_y.lhs, root_node.lhs);
95
96 detail::delete_element(new_root_y.lhs);
97 }
98 else if ( leaf.lhs.type_family == COMPOSITE_OPERATION_FAMILY // temporary for (x)
99 && leaf.rhs.type_family == COMPOSITE_OPERATION_FAMILY) // temporary for (y)
100 {
101 // extract size information from vectors:
102 lhs_rhs_element const & temp_node = detail::extract_representative_vector(s, leaf.lhs);
103
104 // temporary for (x)
105 statement_node new_root_x;
106 detail::new_element(new_root_x.lhs, temp_node, ctx);
107
108 new_root_x.op.type_family = OPERATION_BINARY_TYPE_FAMILY;
109 new_root_x.op.type = OPERATION_BINARY_ASSIGN_TYPE;
110
111 new_root_x.rhs.type_family = COMPOSITE_OPERATION_FAMILY;
112 new_root_x.rhs.subtype = INVALID_SUBTYPE;
113 new_root_x.rhs.numeric_type = INVALID_NUMERIC_TYPE;
114 new_root_x.rhs.node_index = leaf.lhs.node_index;
115
116 // work on subexpression:
117 // TODO: Catch exception, free temporary, then rethrow
118 detail::execute_composite(s, new_root_x);
119
120 // temporary for (y)
121 statement_node new_root_y;
122 detail::new_element(new_root_y.lhs, temp_node, ctx);
123
124 new_root_y.op.type_family = OPERATION_BINARY_TYPE_FAMILY;
125 new_root_y.op.type = OPERATION_BINARY_ASSIGN_TYPE;
126
127 new_root_y.rhs.type_family = COMPOSITE_OPERATION_FAMILY;
128 new_root_y.rhs.subtype = INVALID_SUBTYPE;
129 new_root_y.rhs.numeric_type = INVALID_NUMERIC_TYPE;
130 new_root_y.rhs.node_index = leaf.rhs.node_index;
131
132 // work on subexpression:
133 // TODO: Catch exception, free temporary, then rethrow
134 detail::execute_composite(s, new_root_y);
135
136 // compute inner product:
137 detail::inner_prod_impl(new_root_x.lhs, new_root_y.lhs, root_node.lhs);
138
139 detail::delete_element(new_root_x.lhs);
140 detail::delete_element(new_root_y.lhs);
141 }
142 else
143 throw statement_not_supported_exception("Cannot deal with inner product of the provided arguments");
144 }
145 else if ( leaf.op.type == OPERATION_UNARY_NORM_1_TYPE
146 || leaf.op.type == OPERATION_UNARY_NORM_2_TYPE
147 || leaf.op.type == OPERATION_UNARY_NORM_INF_TYPE
148 || leaf.op.type == OPERATION_UNARY_MAX_TYPE
149 || leaf.op.type == OPERATION_UNARY_MIN_TYPE)
150 {
151 assert(root_node.lhs.type_family == SCALAR_TYPE_FAMILY && bool("Inner product requires assignment to scalar type!"));
152
153 if (leaf.lhs.type_family == VECTOR_TYPE_FAMILY)
154 {
155 detail::norm_impl(leaf.lhs, root_node.lhs, leaf.op.type);
156 }
157 else if (leaf.lhs.type_family == COMPOSITE_OPERATION_FAMILY) //introduce temporary:
158 {
159 lhs_rhs_element const & temp_node = detail::extract_representative_vector(s, leaf.lhs);
160
161 statement_node new_root_y;
162
163 detail::new_element(new_root_y.lhs, temp_node, ctx);
164
165 new_root_y.op.type_family = OPERATION_BINARY_TYPE_FAMILY;
166 new_root_y.op.type = OPERATION_BINARY_ASSIGN_TYPE;
167
168 new_root_y.rhs.type_family = COMPOSITE_OPERATION_FAMILY;
169 new_root_y.rhs.subtype = INVALID_SUBTYPE;
170 new_root_y.rhs.numeric_type = INVALID_NUMERIC_TYPE;
171 new_root_y.rhs.node_index = leaf.lhs.node_index;
172
173 // work on subexpression:
174 // TODO: Catch exception, free temporary, then rethrow
175 detail::execute_composite(s, new_root_y);
176
177 detail::norm_impl(new_root_y.lhs, root_node.lhs, leaf.op.type);
178
179 detail::delete_element(new_root_y.lhs);
180 }
181 else
182 throw statement_not_supported_exception("Cannot deal with norm_inf of the provided arguments");
183 }
184 else
185 throw statement_not_supported_exception("Unsupported operation for scalar.");
186 }
187
188 }
189 } //namespace viennacl
190
191 #endif
192
viennacl::scheduler::OPERATION_UNARY_NORM_INF_TYPE
Definition: forwards.h:109
viennacl::scheduler::detail::inner_prod_impl
void inner_prod_impl(lhs_rhs_element const &x, lhs_rhs_element const &y, lhs_rhs_element const &s)
Dispatcher interface for computing s = inner_prod(x, y)
Definition: execute_vector_dispatcher.hpp:172
execute_vector_dispatcher.hpp
Provides wrappers for av(), avbv(), avbv_v(), etc. in viennacl/linalg/vector_operations.hpp such that scheduler logic is not cluttered with numeric type decutions.
viennacl::scheduler::detail::extract_context
viennacl::context extract_context(statement_node const &root_node)
Helper routine for extracting the context in which a statement is executed.
Definition: execute_util.hpp:105
viennacl::scheduler::detail::norm_impl
void norm_impl(lhs_rhs_element const &x, lhs_rhs_element const &s, operation_node_type op_type)
Dispatcher interface for computing s = norm_1(x)
Definition: execute_vector_dispatcher.hpp:128
viennacl::scheduler::INVALID_SUBTYPE
Definition: forwards.h:266
viennacl::scheduler::lhs_rhs_element::subtype
statement_node_subtype subtype
Definition: forwards.h:340
viennacl::scheduler::execute_scalar_assign_composite
void execute_scalar_assign_composite(statement const &s, statement_node const &root_node)
Deals with x = RHS where RHS is a vector expression.
Definition: execute_scalar_assign.hpp:37
viennacl::scheduler::statement_node::op
op_element op
Definition: forwards.h:481
viennacl::scheduler::SCALAR_TYPE_FAMILY
Definition: forwards.h:254
forwards.h
This file provides the forward declarations for the main types used within ViennaCL.
viennacl::scheduler::lhs_rhs_element::type_family
statement_node_type_family type_family
Definition: forwards.h:339
viennacl::scheduler::OPERATION_BINARY_ASSIGN_TYPE
Definition: forwards.h:115
viennacl::scheduler::lhs_rhs_element
A class representing the 'data' for the LHS or RHS operand of the respective node.
Definition: forwards.h:337
viennacl::scheduler::statement::array
container_type const & array() const
Definition: forwards.h:528
viennacl::scheduler::op_element::type_family
operation_node_type_family type_family
Definition: forwards.h:473
viennacl::scheduler::detail::delete_element
void delete_element(lhs_rhs_element &elem)
Definition: execute_util.hpp:266
viennacl::context
Represents a generic 'context' similar to an OpenCL context, but is backend-agnostic and thus also su...
Definition: context.hpp:39
viennacl::scheduler::COMPOSITE_OPERATION_FAMILY
Definition: forwards.h:251
viennacl::scheduler::OPERATION_UNARY_NORM_2_TYPE
Definition: forwards.h:108
viennacl::scheduler::OPERATION_BINARY_INNER_PROD_TYPE
Definition: forwards.h:146
viennacl::scheduler::OPERATION_UNARY_MAX_TYPE
Definition: forwards.h:110
viennacl::scheduler::INVALID_NUMERIC_TYPE
Definition: forwards.h:288
viennacl::scheduler::lhs_rhs_element::numeric_type
statement_node_numeric_type numeric_type
Definition: forwards.h:341
viennacl::scheduler::statement_node::rhs
lhs_rhs_element rhs
Definition: forwards.h:482
viennacl::scheduler::statement_node::lhs
lhs_rhs_element lhs
Definition: forwards.h:480
viennacl::scheduler::OPERATION_BINARY_TYPE_FAMILY
Definition: forwards.h:59
forwards.h
Provides the datastructures for dealing with a single statement such as 'x = y + z;'.
viennacl::scheduler::detail::execute_composite
void execute_composite(statement const &s, statement_node const &root_node)
Deals with x = RHS where RHS is an expression and x is either a scalar, a vector, or a matrix...
Definition: execute.hpp:42
viennacl::scheduler::OPERATION_UNARY_MIN_TYPE
Definition: forwards.h:111
viennacl::scheduler::detail::new_element
void new_element(lhs_rhs_element &new_elem, lhs_rhs_element const &old_element, viennacl::context const &ctx)
Definition: execute_util.hpp:204
viennacl::scheduler::op_element::type
operation_node_type type
Definition: forwards.h:474
viennacl::scheduler::detail::extract_representative_vector
lhs_rhs_element const & extract_representative_vector(statement const &s, lhs_rhs_element const &element)
Definition: execute_util.hpp:41
viennacl::scheduler::statement
The main class for representing a statement such as x = inner_prod(y,z); at runtime.
Definition: forwards.h:502
viennacl::scheduler::lhs_rhs_element::node_index
vcl_size_t node_index
Definition: forwards.h:346
viennacl::scheduler::VECTOR_TYPE_FAMILY
Definition: forwards.h:257
execute_util.hpp
Provides various utilities for implementing the execution of statements.
viennacl::scheduler::statement_node
Main datastructure for an node in the statement tree.
Definition: forwards.h:478
viennacl::scheduler::statement_not_supported_exception
Exception for the case the scheduler is unable to deal with the operation.
Definition: forwards.h:38
viennacl::scheduler::OPERATION_UNARY_NORM_1_TYPE
Definition: forwards.h:107