~gabriel1984sibiu/octave/octave

Next: <a href="Examples.html#Examples" accesskey="n" rel="next">Examples</a>, Previous: <a href="JIT-Compiler.html#JIT-Compiler" accesskey="p" rel="prev">JIT Compiler</a>, Up: <a href="Vectorization-and-Faster-Code-Execution.html#Vectorization-and-Faster-Code-Execution" accesskey="u" rel="up">Vectorization and Faster Code Execution</a>   [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Concept-Index.html#Concept-Index" title="Index" rel="index">Index</a>]</p>

</div>

<hr>

<h3 class="section">19.6 Miscellaneous Techniques</h3>

<p>Here are some other ways of improving the execution speed of Octave

programs.

</p>

<ul>

<li> Avoid computing costly intermediate results multiple times.

Octave currently does not eliminate common subexpressions. Also, certain

internal computation results are cached for variables. For instance, if

a matrix variable is used multiple times as an index, checking the

indices (and internal conversion to integers) is only done once.

</li><li> Be aware of lazy copies (copy-on-write).

When a copy of an object is created, the data is not immediately copied, but

rather shared. The actual copying is postponed until the copied data needs to

be modified. For example:

<pre class="example">a = zeros (1000); # create a 1000x1000 matrix

b = a; # no copying done here

b(1) = 1; # copying done here

</pre></div>

<p>Lazy copying applies to whole Octave objects such as matrices, cells,

struct, and also individual cell or struct elements (not array

elements).

</p>

<p>Additionally, index expressions also use lazy copying when Octave can

determine that the indexed portion is contiguous in memory. For example:

</p>

<pre class="example">a = zeros (1000); # create a 1000x1000 matrix

b = a(:,10:100); # no copying done here

b = a(10:100,:); # copying done here

</pre></div>

100

101

<p>This applies to arrays (matrices), cell arrays, and structs indexed

102

using ‘<samp>()</samp>’. Index expressions generating comma-separated lists can also

103

benefit from shallow copying in some cases. In particular, when <var>a</var> is a

104

struct array, expressions like <code>{a.x}, {a(:,2).x}</code> will use lazy

105

copying, so that data can be shared between a struct array and a cell array.

106

</p>

107

<p>Most indexing expressions do not live longer than their parent

108

objects. In rare cases, however, a lazily copied slice outlasts its

109

parent, in which case it becomes orphaned, still occupying unnecessarily

110

more memory than needed. To provide a remedy working in most real cases,

111

Octave checks for orphaned lazy slices at certain situations, when a

112

value is stored into a "permanent" location, such as a named variable or

113

cell or struct element, and possibly economizes them. For example:

114

</p>

115

116

<pre class="example">a = zeros (1000); # create a 1000x1000 matrix

117

b = a(:,10:100); # lazy slice

118

a = []; # the original "a" array is still allocated

119

c{1} = b; # b is reallocated at this point

120

</pre></div>

121

122

</li><li> Avoid deep recursion.

123

Function calls to m-file functions carry a relatively significant overhead, so

124

rewriting a recursion as a loop often helps. Also, note that the maximum level

125

of recursion is limited.

126

127

</li><li> Avoid resizing matrices unnecessarily.

128

When building a single result matrix from a series of calculations, set the

129

size of the result matrix first, then insert values into it. Write

130

131

132

<pre class="example">result = zeros (big_n, big_m)

133

for i = over:and_over

134

ridx = …

135

cidx = …

136

result(ridx, cidx) = new_value ();

137

endfor

138

</pre></div>

139

140

<p>instead of

141

</p>

142

143

<pre class="example">result = [];

144

for i = ever:and_ever

145

result = [ result, new_value() ];

146

endfor

147

</pre></div>

148

149

<p>Sometimes the number of items can not be computed in advance, and

150

stack-like operations are needed. When elements are being repeatedly

151

inserted or removed from the end of an array, Octave detects it as stack

152

usage and attempts to use a smarter memory management strategy by

153

pre-allocating the array in bigger chunks. This strategy is also applied

154

to cell and struct arrays.

155

</p>

156

157

<pre class="example">a = [];

158

while (condition)

159

…

160

a(end+1) = value; # "push" operation

161

…

162

a(end) = []; # "pop" operation

163

…

164

endwhile

165

</pre></div>

166

167

</li><li> Avoid calling <code>eval</code> or <code>feval</code> excessively.

168

Parsing input or looking up the name of a function in the symbol table are

169

relatively expensive operations.

170

171

<p>If you are using <code>eval</code> merely as an exception handling mechanism, and not

172

because you need to execute some arbitrary text, use the <code>try</code>

173

statement instead. See <a href="The-try-Statement.html#The-try-Statement">The try Statement</a>.

174

</p>

175

</li><li> Use <code>ignore_function_time_stamp</code> when appropriate.

176

If you are calling lots of functions, and none of them will need to change

177

during your run, set the variable <code>ignore_function_time_stamp</code> to

178

<code>"all"</code>. This will stop Octave from checking the time stamp of a function

179

file to see if it has been updated while the program is being run.

180

</li></ul>

181

182

<hr>

183

184

<p>

185

186

</div>

187

188

189

190

</body>

191

</html>

Older »