My Matlab code (the same one) is running extremely slow on a fairly new and powerful PC and is running fast (10x times faster) on my weaker laptops

My Matlab (R2017A) code (the same one) is running extremely slow on a fairly new and powerful PC (AMD Ryzen 7 1700 8core 3Ghz, 16GB Ram) and is running fast (10x times faster) on my older and weaker laptops (dell xps 15 and dell alienware). The code basically uploads and analyze video frames, nothing special. Either I have problems with the hardware or with the Matlab. Please advise on how I can check whether the issue is with Matlab and, if there is one, how to fix it.

[dpb]

Which OS on each and which ML Release on each?

Check that 'renderer' is using hardware on the PC; maybe you've got a new video driver that isn't being recognized of somesuch.

How much memory is on the laptop altho I doubt there's any more, might as well ask/eliminate the obvious first... :)

[Taisiya Sigaeva]

PC with the issue: Windows 10 Enterprise '9.2.0.556344 (R2017a)'

Laptop without issue dell xps 15, 8GB Ram Inter core i7-7700hq 2.8Hz: Windows 10 Home '9.2.0.556344 (R2017a)'

[Taisiya Sigaeva]

I am not sure if I am correct, but to check the render I typed opengl info

PC: Version: '4.5.13492 Compatibility Profile Context 22.19.677.257'
Vendor: 'ATI Technologies Inc.' Renderer: 'Radeon RX 580 Series' 
RendererDriverVersion: '22.19.677.257'
RendererDriverReleaseDate: '22-Sep-2017'
MaxTextureSize: 16384 
Visual: 'Visual 0x08, (RGBA 32 bits (8 8 8 8), Z depth 16 bits, Hardware acceleration, Double buffer, Antialias 8 samples)' 
Software: 'false' 
HardwareSupportLevel: 'full' 
SupportsGraphicsSmoothing: 1 
SupportsDepthPeelTransparency: 1 
SupportsAlignVertexCenters: 1 
Extensions: {291×1 cell} 
MaxFrameBufferSize: 16384

Laptop:Version: '4.6.0 NVIDIA 388.16' 
Vendor: 'NVIDIA Corporation' 
Renderer: 'GeForce GTX 1050/PCIe/SSE2' 
RendererDriverVersion: '23.21.13.8816' 
RendererDriverReleaseDate: '30-Oct-2017' 
MaxTextureSize: 32768 
Visual: 'Visual 0x09, (RGBA 32 bits (8 8 8 8), Z depth 16 bits, Hardware acceleration, Double buffer, Antialias 8 samples)' 
Software: 'false' 
HardwareSupportLevel: 'full' 
SupportsGraphicsSmoothing: 1 
SupportsDepthPeelTransparency: 1 
SupportsAlignVertexCenters: 1 Extensions: {375×1 cell} MaxFrameBufferSize: 32768

[Masoumeh Parseh]

Hi,

I am facing the exact issue. I am running the same code on a new powerful PC (core i7-8700k, up to 4.7 GHZ, 6 cores, 12MB cache, and 32G RAM) and a macbook pro 2015 (core i7, 3.1 GHZ, 2 cores, 16G RAM). The mac is quite faster (50 seconds on mac and 300seconds on PC). I am wondering if you solved the issue and if someone has any hints.

the only differnece is that I am running MATLAB 2019 on PC and 2018b on mac. I tried 2017a on mac to see what would be the difference between different versions and 2017a was 4 seconds faster.

[Jan]

Without knowing the code of the bottleneck, it is impossible to guess the reason. So please use the profiler on both machines and determine, where the most time is spent.

[Jesse Beaupre]

R2018 is broken, R2014 was the last functionnal version of Matlab.

[Rik]

@Jesse, while I agree that HG2 has caused some issues in performance in some scenarios, statements like the one you posted ignore the nuances of the situation.

If you want ease of development and nice graphics, use a modern release. If you want blazing fast running code (but fewer development tools and less nice graphics), use Matlab 6.5. If you want a middle ground between the two, pick something between R2011a and R2014a.

And even that paragraph is ignoring a lot of possible nuance. If you want simple answers, don't ask the question which release is a 'functional version of Matlab'.

[Richa Ghosh]

@ Rik that actually is a really good suggestion! I have downgraded from 2022 version to 2014a and voila! Problem solved! Thank you! :)

[Dyuman Joshi]

@Rik, can you explain a bit more about how you know this stuff to a noob? Is there any related information given with a version release?

Answer 1

[Rik]

I started to write this as a comment, but I realized this makes more sense as an answer.

These are the general trends for newer releases:

1. Increased speed for many function.
2. Lower speed for some functions (but generally not in the long run).
3. Slower startup of Matlab.
4. More RAM required.
5. More features related to debugging and meta-programming (unit testing etc).
6. More wrapper features (e.g. most (all?) of the features of the table class could be replacted with a custom class wrapping a struct array, and a string is mostly interchangeable with a cellstr).

While the general trend is that functions get faster, this is not necessarily true for graphics interactions. You will have to do tests yourself on the functions you use. If not, you will have to rely on the performance numbers Mathworks reports. And while they will not lie, they are unlikely to showcase performance regressions.

What I wrote in my comment above still stands: if you want ease of development and nice graphics, use a modern release. If you want blazing fast running code (but fewer development tools and less nice graphics), use Matlab 6.5.

The middle ground between the current release and 6.5 is of course always moving. If you experience severe bottlenecks in modern releases related to graphics, I would suggest something between R2011a and R2014a (which all have a similar UI and have HG1). I would say the next big jump is with the merging of most of the features of the live editor into the normal editor in R2021b. If your computer can handle it, I would currently suggest using R2021b or newer.

So these are the ranges I would distinguish:

• Matlab 6.5: very fast (but also lacking a lot of features and debugging tools)
• R2011a-R2014a: relatively new HG1 releases
• R2014b-R2021a: HG2 releases with the old editor
• R2021b-newer: HG2 releases with a new editor

@Dyuman Joshi I don't really have a source for this, I just picked this up over the years. There are release notes for every release (the last 5 years should be available online: https://www.mathworks.com/help/matlab/release-notes.html), detailing the most important changes. There isn't really a comparison for the changes for every function.

[Dyuman Joshi]

Thanks for the answer, @Rik. It is quite informative!

I was quite aware of points 3 and 4, somewhat about point 5. Also, noted your 1st paragrah!

I am not from a Computer science background, so I have a very limited knowledge about this. I had to search what a Wrapper function was.

Also, What is HG? (HG1 and HG2)

[Walter Roberson]

"HG" stands for "Handle Graphics". HG1 was the system up to R2014a; HG2 is the system from R2014b.

[Dyuman Joshi]

I assume they are equivalent to Graphics Object Handles?

[Rik]

No, they are actually not equivalent to handles of graphics objects.

In HG1, handles are stored as a double. You can still see this with figures, where you can also use integers instead of the actual handle object. This allowed much flexibility in terms of storage.

In HG2, handles are stored as objects. This facilitated using the dot-indexing to access properties: Fig.Position instead of get(Fig,'Position').

There are more differences below the surface, but since they are hardly ever relevant for me, I haven't researched the topic thoroughly.

And about the wrapper function: what I mean amount to an interface. For the case of string that would mean you create a class that stores the text internally in a cell array of char vectors, but you use the methods to overload plus to allow this to work. As you can see, you can replicate the same behavior with a cellstr. If you have a week of spare time, you could overload disp to show double quotes and overload all other customizations. At the end you will have the same functionality as string, without using string itself.

["abc";"def"]+[123 456]

ans = 2×2 string array
    "abc123"    "abc456"
    "def123"    "def456"

overloaded_plus({'abc';'def'},[123 456])

ans = 2×2 cell array
    {'abc123'}    {'abc456'}
    {'def123'}    {'def456'}

function out=overloaded_plus(arg1,arg2)
% bare-bones example of how you could replicate the plus behavior of the
% string datatype with only cellstr.
% This uses bsxfun and will therefore 'only' work on R2007a or later.

% Swap order if the cellstr is the second argument
if ~iscellstr(arg1)
    swapped_args=true;
    [arg2,arg1]=deal(arg1,arg2);
else
    swapped_args=false;
end

% Convert numeric to cellstr.
if isnumeric(arg2)
    arg2=cellfun(@num2str,num2cell(arg2),'UniformOutput',false);
end

% Extend the array sizes with a terrible hack (don't use this).
ones_arg1=ones(size(arg1));
ones_arg2=ones(size(arg2));
result=bsxfun(@plus,ones_arg1,ones_arg2); % Allow implicit expansion.
arg1=repmat(arg1, size(result)./size(ones_arg1) );
arg2=repmat(arg2, size(result)./size(ones_arg2) );

if swapped_args
    [arg2,arg1]=deal(arg1,arg2);
end
out=cellfun(@horzcat,arg1,arg2,'UniformOutput',false);
end