blocks|key|3894332|text|在我的经验中，缓慢的MATLAB代码通常来自于没有向量化你的代码(例如，编写for循环而不只是乘法数组(简单的例子))。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3894333|如果您正在进行文件I/O，请注意一次读取一个块中的数据。在帮助文件中查找fscanf的矢量化版本。|3894334|不要忘记，MATLAB还包含一个分析器！|3894335|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

In my experience slow MATLAB code usually comes from not vectorizing your code (i.e., writing for-loops instead of just multiplying arrays (simple example)). 

If you are doing file I/O look out for reading data in one piece at a time. Look in the help files for the vectorized version of fscanf. 

Don't forget that MATLAB includes a profiler, too!

blocks|key|777857|text|提到Matlab编译器，您可能指的是命令mcc，它确实通过绕过Matlab解释器来提高代码速度。将显着提高MAtlab代码速度(提高50-200倍)的是使用由mex命令编译的实际C代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|777858|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

By Matlab compiler you probably mean the command mcc, which does speed the code a little bit by circumventing Matlab interpreter. What would speed the MAtlab code significantly (by a factor of 50-200) is use of actual C code compiled by the mex command.

blocks|key|5305267|text|我将附和dwj所说的话:如果你的MATLAB代码很慢，这可能是因为它没有足够的矢量化。如果你在可以对整个数组进行操作的时候进行显式循环，那就是罪魁祸首。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5305268|这同样适用于所有面向数组的动态语言:+Perl+Data+Language、Numeric、MATLAB/Octave等。在编译的C和FORTRAN编译代码中甚至在某种程度上也是如此:特殊设计的矢量化库通常使用精心编写的内部循环和单指令多数据指令集(如MMX、SSE、AltiVec)。|5305269|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I'll echo what dwj said: if your MATLAB code is slow, this is probably because it is not sufficiently vectorized. If you're doing explicit loops when you could be doing operations on whole arrays, that's the culprit.

This applies equally to all array-oriented dynamic languages: Perl Data Language, Numeric Python, MATLAB/Octave, etc. It's even true to some extent in compiled C and FORTRAN compiled code: specially-designed vectorization libraries generally use carefully hand-coded inner loops and SIMD instructions (e.g. MMX, SSE, AltiVec).

blocks|key|3894492|text|正如其他人所指出的，缓慢的Matlab代码通常是向量化不足的结果。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3894493|然而，有时即使是完全矢量化的代码也很慢。然后，您还有几个选项：|3894494|3894495|查看是否有可以使用的库/工具箱。这些通常被写成非常optimized.|ordered-list-item|3894496|Profile你的代码，找出不足之处，然后用普通的C重写它们。将C代码(例如DLL)连接到Matlab是很容易的，在documentation.|3894497|中有介绍|3894498|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|Q|8|@]|9|@]|A|$]]|$1|H|3|I|5|G|7|R|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|M|$]]

As others has noted, slow Matlab code is often the result of insufficient vectorization.

However, sometimes even perfectly vectorized code is slow. Then, you have several more options:

<ol>
<li>See if there are any libraries / toolboxes you can use. These were usually written to be very optimized.</li>
<li>Profile your code, find the tight spots and rewrite those in plain C. Connecting C code (as DLLs for instance) to Matlab is easy and is covered in the documentation.</li>
</ol>

blocks|key|780688|text|如果您使用的是MATLAB+complier+(在MATLAB的最新版本上)，那么您几乎肯定不会看到任何加速。这是因为编译器实际上所做的就是为您提供了一种打包代码的方法，以便将其分发给没有MATLAB的人。它不会把它转换成任何更快的东西(比如机器码或C语言)--它只是用C语言包装它，这样你就可以调用它了。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|780689|它通过让你的代码在MATLAB编译器运行时(MCR)上运行来做到这一点，MCR本质上就是MATLAB的计算内核--你的代码仍然在被解释。由于必须调用MCR而带来的损失，您可能会发现编译后的代码运行起来比在MATLAB上运行要慢得多。|780690|换一种方式--你可能会说编译器实际上并没有编译--至少在传统意义上是这样。|780691|旧版本的编译器工作方式不同，在某些情况下可能会出现加速。有关Mathwork对此的看法，请访问|780692|http://www.mathworks.com/support/solutions/data/1-1ARNS.html|780693|entityMap|0|LINK|mutability|MUTABLE|url|http://www.mathworks.com/products/compiler/|1^0|7|F|0|0|0|0|0|0|1O|1|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|10|8|@]|9|@]|C|$]]|$1|J|3|K|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|L|3|-4|5|6|7|15|8|@]|9|@]|C|$]]]|M|$N|$5|O|P|Q|C|$R|S]]|T|$5|O|P|Q|C|$R|K]]]]

If you are using the <a href="http://www.mathworks.com/products/compiler/" rel="noreferrer">MATLAB complier</a> (on a recent version of MATLAB) then you will almost certainly not see any speedups at all. This is because all the compiler actually does is give you a way of packaging up your code so that it can be distributed to people who don't have MATLAB. It doesn't convert it to anything faster (such as machine code or C) - it merely wraps it in C so you can call it.

It does this by getting your code to run on the MATLAB Compiler Runtime (MCR) which is essentially the MATLAB computational kernel - your code is still being interpreted. Thanks to the penalty incurred by having to invoke the MCR you may find that compiled code runs more slowly than if you simply ran it on MATLAB.

Put another way - you might say that the compiler doesn't actually compile - in the traditional sense of the word at least.

Older versions of the compiler worked differently and speedups could occur in certain situations. For Mathwork's take on this go to

<a href="http://www.mathworks.com/support/solutions/data/1-1ARNS.html" rel="noreferrer">http://www.mathworks.com/support/solutions/data/1-1ARNS.html</a>

blocks|key|3049784|text|mcc根本不会加速您的代码--它不是真正的编译器。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3049785|在你放弃之前，你需要运行分析器，弄清楚你所有的时间都花在哪里了(Tools->Open+Profiler)。此外，明智地使用"tic“和"toc”也会有所帮助。不要优化你的代码，直到你知道时间的去向(不要尝试猜测)。|3049786|请记住，在matlab中：|3049787|3049788|位级操作非常慢|unordered-list-item|3049789|文件I/O很慢|3049790|循环通常很慢，但向量化很快(如果您不了解向量语法，请学习它)|3049791|核心操作非常快(例如，矩阵乘法，fft)|3049792|如果您认为可以用C/Fortran/etc做一些更快的事情，您可以编写一个MEX文件|3049793|有一些商业解决方案可以将matlab转换为C(谷歌"matlab+to+c")，它们是有效的|3049794|3049795|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|10|8|@]|9|@]|A|$]]|$1|J|3|K|5|I|7|11|8|@]|9|@]|A|$]]|$1|L|3|M|5|I|7|12|8|@]|9|@]|A|$]]|$1|N|3|O|5|I|7|13|8|@]|9|@]|A|$]]|$1|P|3|Q|5|I|7|14|8|@]|9|@]|A|$]]|$1|R|3|S|5|I|7|15|8|@]|9|@]|A|$]]|$1|T|3|-4|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

mcc won't speed up your code at all--it's not really a compiler. 

Before you give up, you need to run the profiler and figure out where all your time is going (Tools->Open Profiler). Also, judicious use of "tic" and "toc" can help. Don't optimize your code until you know where the time is going (don't try to guess).

Keep in mind that in matlab:

<ul>
<li>bit-level operations are really slow</li>
<li>file I/O is slow</li>
<li>loops are generally slow, but vectorizing is fast (if you don't know the vector syntax, learn it)</li>
<li>core operations are really fast (e.g. matrix multiply, fft)</li>
<li>if you think you can do something faster in C/Fortran/etc, you can write a MEX file</li>
<li>there are commercial solutions to convert matlab to C (google "matlab to c") and they work</li>
</ul>

blocks|key|3049872|text|首先，我重复上面关于分析和矢量化的所有评论。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3049873|从历史的角度来看...|3049874|旧版本的Matlab允许用户通过预先解析m代码并将其转换为一组matlab库调用，将m文件转换为mex函数。这些调用具有解释器所做的所有错误检查，但是旧版本的解释器和/或在线解析器速度很慢，因此编译m文件有时会有所帮助。当你有循环时，它通常会有帮助，因为Matlab足够聪明，可以在C中内联其中的一些循环。如果你有这些版本的Matlab，你可以尝试告诉mex脚本保存.c文件，你可以确切地看到它在做什么。|3049875|在较新的版本(可能是2006a或更高版本，但我不记得了)中，Mathworks开始为解释器使用即时编译器。实际上，这个JIT编译器会自动编译所有的mex函数，所以显式地脱机编译根本没有任何帮助。从那时起，在每个版本中，他们也投入了大量的精力来提高解释器的速度。我相信新版本的Matlab甚至不能自动将m文件编译成mex文件，因为它已经不再有意义了。|3049876|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

First, I second all the above comments about profiling and vectorizing. 

For a historical perspective...

Older version of Matlab allowed the user to convert m files to mex functions by pre-parsing the m code and converting it to a set of matlab library calls. These calls have all the error checking that the interpreter did, but old versions of the interpreter and/or online parser were slow, so compiling the m file would sometimes help. Usually it helped when you had loops because Matlab was smart enough to inline some of that in C. If you have one of those versions of Matlab, you can try telling the mex script to save the .c file and you can see exactly what it's doing. 

In more recent version (probably 2006a and later, but I don't remember), Mathworks started using a just-in-time compiler for the interpreter. In effect, this JIT compiler automatically compiles all mex functions, so explicitly doing it offline doesn't help at all. In each version since then, they've also put a lot of effort into making the interpreter much faster. I believe that newer versions of Matlab don't even let you automatically compile m files to mex files because it doesn't make sense any more.

blocks|key|3894859|text|你有没有试过分析你的代码？您不需要向量化所有的代码，只需要向量化主宰运行时间的函数。MATLAB分析器会给你一些提示，告诉你你的代码在哪里花费了最多的时间。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3894860|在MathWorks手册的Tips+For+Improving+Performance一节中，您还应该阅读许多其他内容。|offset|length|3894861|entityMap|0|LINK|mutability|MUTABLE|url|http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_prog/f8-784135.html^0|0|D|U|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

Have you tried profiling your code? You don't need to vectorize ALL your code, just the functions that dominate running time. The MATLAB profiler will give you some hints on where your code is spending the most time. 

There are many other things you you should read up on the <a href="http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_prog/f8-784135.html" rel="nofollow noreferrer">Tips For Improving Performance</a> section in the MathWorks manual.

blocks|key|3050146|text|您可以将代码移植到"Embedded+Matlab“，然后使用Realtime-Workshop将其转换为C语言。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3050147|嵌入式Matlab是Matlab的一个子集。它不支持单元数组、图形、动态大小的数字或某些矩阵寻址模式。移植到嵌入式Matlab可能需要付出相当大的努力。|3050148|实时研讨会是代码生成产品的核心。它提供了通用的C语言，或者可以针对一系列嵌入式平台进行优化。您最感兴趣的可能是xPC-+target，它将通用硬件视为嵌入式目标。|3050149|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

You could port your code to "Embedded Matlab" and then use the Realtime-Workshop to translate it to C.

Embedded Matlab is a subset of Matlab. It does not support Cell-Arrays, Graphics, Marices of dynamic size, or some Matrix addressing modes. It may take considerable effort to port to Embedded Matlab.

Realtime-Workshop is at the core of the Code Generation Products. It spits out generic C, or can optimize for a range of embedded Platforms. Most interresting to you is perhaps the xPC-Target, which treats general purpose hardware as embedded target.

blocks|key|778208|text|MATLAB编译器包装您的m代码并将其分派到MATLAB运行时。因此，您在MATLAB中看到的性能应该是您在编译器中看到的性能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|778209|根据其他答案，向量化你的代码是有帮助的。但是，MATLAB+JIT现在相当不错，许多东西的性能大致与矢量化与否一样好。这并不是说矢量化不能带来性能上的好处，它只是不再像以前那样神奇了。唯一能说明问题的方法就是使用分析器找出代码中的瓶颈所在。通常情况下，您可以在某些地方进行本地重构，以真正提高代码的性能。|778210|您还可以采用其他一些硬件方法来提高性能。首先，大部分线性代数子系统都是多线程的。如果您在多核或多处理器平台上工作，则可能需要确保已在首选项中启用此功能。其次，您可以使用并行计算工具箱来更好地利用多处理器。最后，如果您是Simulink用户，则可以使用emlmex将m代码编译成c。这对于定点工作特别有效。|778211|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

The MATLAB compiler wraps up your m-code and dispatches it to a MATLAB runtime. So, the performance you see in MATLAB should be the performance you see with the compiler.

Per the other answers, vectorizing your code is helpful. But, the MATLAB JIT is pretty good these days and lots of things perform roughly as well vectorized or not. That'a not to say there aren't performance benefits to be gained from vectorization, it's just not the magic bullet it once was. The only way to really tell is to use the profiler to find out where your code is seeing bottlenecks. Often times there are some places where you can do local refactoring to really improve the performance of your code.

There are a couple of other hardware approaches you can take on performance. First, much of the linear algebra subsystem is multithreaded. You may want to make sure you have enabled that in your preferences if you are working on a multi-core or multi-processor platform. Second, you may be able to use the parallel computing toolbox to take more advantage of multiple processors. Finally, if you are a Simulink user, you may be able to use emlmex to compile m-code into c. This is particularly effective for fixed point work.

blocks|key|3895137|text|我会投票支持分析%2B，然后看看瓶颈是什么。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3895138|如果瓶颈是矩阵数学，你可能不会做得更好……除了一个很大的陷阱是数组分配。例如，如果你有一个循环：|3895139|s+=+[];
for+i+=+1:50000
++s(i)+=+3;
end|code-block|syntax|javascript|3895140|这必须不断调整数组的大小；预置数组的大小(从0或NaN开始)并从那里填充它要快得多：|3895141|s+=+zeros(50000,1);
for+i+=+1:50000
++s(i)+=+3;
end|3895142|如果瓶颈是重复执行大量函数调用，那就很难了。|3895143|如果瓶颈是MATLAB不能快速完成的东西(某些类型的解析，XML，诸如此类的东西)，那么我会使用Java，因为MATLAB已经在JVM上运行，并且它很容易与任意JAR文件进行接口。我看过C/C%2B%2B的接口，它真的很难看。微软的COM是可以的(只在Windows上)，但在学习了Java之后，我想我再也不会回到那个地方了。|3895144|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

I would vote for profiling + then look at what are the bottlenecks. 

If the bottleneck is matrix math, you're probably not going to do any better... EXCEPT one big gotcha is array allocation. e.g. if you have a loop:

<pre><code>s = [];
for i = 1:50000
 s(i) = 3;
end
</code></pre>

This has to keep resizing the array; it's much faster to presize the array (start with zeros or NaN) &amp; fill it from there:

<pre><code>s = zeros(50000,1);
for i = 1:50000
 s(i) = 3;
end
</code></pre>

If the bottleneck is repeated executions of a lot of function calls, that's a tough one.

If the bottleneck is stuff that MATLAB doesn't do quickly (certain types of parsing, XML, stuff like that) then I would use Java since MATLAB already runs on a JVM and it interfaces really easily to arbitrary JAR files. I looked at interfacing with C/C++ and it's REALLY ugly. Microsoft COM is ok (on Windows only) but after learning Java I don't think I'll ever go back to that.

I have a lot of nice MATLAB code that runs too slowly and would be a pain to write over in C. The MATLAB compiler for C does not seem to help much, if at all. Should it be speeding execution up more? Am I screwed?

Why don't I see a significant speed-up when using the MATLAB compiler?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我有很多很好的MATLAB代码，运行速度太慢，用C编写会很痛苦。MATLAB编译器对C的帮助似乎不大，如果有帮助的话。它应该更快地执行吗？我完蛋了吗？

问为什么在使用MATLAB编译器时，我看不到显著的加速？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么在使用MATLAB编译器时，我看不到显著的加速？EN