C / C++ / MFC

led mike3-Mar-08 6:32

led mike

3-Mar-08 6:32

Stephen Hewitt wrote:
Contrary to what some people have been saying, in most cases using a vector is just as fast as using raw memory allocation functions.

Hey Stephen, I just stumbled upon this old thread. In general or specifically for business apps STL is more than adequate. However I do have some minor experience in Console Gaming development and for the graphics rendering I do believe the point being made about DirectX for example might be valid. Rendering, several years back when I was involved, was a huge bottleneck and some advances have been made in that area and I seem to remember reading about what Rajkumar_R is talking about in DirectX. For production graphics I would think one would certainly want to use the current approach being supported by any particular graphics platform.

led mike

Stephen Hewitt4-Jun-07 15:01

Re: Vector of Pointers [modified]

4-Jun-07 15:01

Rajkumar_R wrote:
vector<char> vecObj; char c = vecObj[3] is very slow compared to a simple
char Array[10]; char c = Array[3];

Nonsense. All of a std::vectors functions are small inline functions. Using a vector is, in most cases, just as efficient.

Steve

Rajkumar R4-Jun-07 18:49

4-Jun-07 18:49

Hi Steve,
Thanks for your comments,

But I would like you to see the code in low level,
This is the dissasembly of code for vector and normal array

simple array

 c = Array[2];
00411A2F  mov         al,byte ptr [ebp-0DAh] 
00411A35  mov         byte ptr [ebp-0A5h],al

vector

 c = vecObj[2];
00411A1A  push        2    
00411A1C  lea         ecx,[ebp-0D0h] 
00411A22  call        std::vector<int,std::allocator<int> >::operator[] (4114ECh) 
00411A27  mov         al,byte ptr [eax] 
00411A29  mov         byte ptr [ebp-0A5h],al

and the call to operator [] disassembles to

reference operator[](size_type _Pos)
		{	// subscript mutable sequence
00411E40  push        ebp  
00411E41  mov         ebp,esp 
00411E43  sub         esp,0CCh 
00411E49  push        ebx  
00411E4A  push        esi  
00411E4B  push        edi  
00411E4C  push        ecx  
00411E4D  lea         edi,[ebp-0CCh] 
00411E53  mov         ecx,33h 
00411E58  mov         eax,0CCCCCCCCh 
00411E5D  rep stos    dword ptr es:[edi] 
00411E5F  pop         ecx  
00411E60  mov         dword ptr [ebp-8],ecx 

 #if _HAS_ITERATOR_DEBUGGING
		if (size() <= _Pos)
00411E63  mov         ecx,dword ptr [this] 
00411E66  call        std::vector<int,std::allocator<int> >::size (41159Bh) 
00411E6B  cmp         eax,dword ptr [_Pos] 
00411E6E  ja          std::vector<char,std::allocator<char> >::operator[]+0A8h (411EE8h) 
			{
			_DEBUG_ERROR("vector subscript out of range");
00411E70  mov         esi,esp 
00411E72  push        2F4h 
00411E77  push        offset string L"c:\\program files\\mic"... (41B8B0h) 
00411E7C  push        offset string L"vector subscript out"... (41B868h) 
00411E81  call        dword ptr [__imp_std::_Debug_message (41F3D0h)] 
00411E87  add         esp,0Ch 
00411E8A  cmp         esi,esp 
00411E8C  call        @ILT+835(__RTC_CheckEsp) (411348h) 
			_SCL_SECURE_OUT_OF_RANGE;
00411E91  xor         eax,eax 
00411E93  jne         std::vector<char,std::allocator<char> >::operator[]+80h (411EC0h) 
00411E95  mov         esi,esp 
00411E97  push        offset string L"("Standard C++ Libra"... (41B800h) 
00411E9C  push        0    
00411E9E  push        2F5h 
00411EA3  push        offset string L"c:\\program files\\mic"... (41B8B0h) 
00411EA8  push        2    
00411EAA  call        dword ptr [__imp___CrtDbgReportW (41F4D4h)] 
00411EB0  add         esp,14h 
00411EB3  cmp         esi,esp 
00411EB5  call        @ILT+835(__RTC_CheckEsp) (411348h) 
00411EBA  cmp         eax,1 
00411EBD  jne         std::vector<char,std::allocator<char> >::operator[]+80h (411EC0h) 
00411EBF  int         3    
00411EC0  mov         esi,esp 
00411EC2  push        0    
00411EC4  push        2F5h 
00411EC9  push        offset string L"c:\\program files\\mic"... (41B8B0h) 
00411ECE  push        offset string L"std::vector<char,cla"... (41B778h) 
00411ED3  push        offset string L""out of range"" (41B750h) 
00411ED8  call        dword ptr [__imp___invalid_parameter (41F4D8h)] 
00411EDE  add         esp,14h 
00411EE1  cmp         esi,esp 
00411EE3  call        @ILT+835(__RTC_CheckEsp) (411348h) 
			}
 #endif /* _HAS_ITERATOR_DEBUGGING */
		_SCL_SECURE_VALIDATE_RANGE(_Pos < size());
00411EE8  mov         ecx,dword ptr [this] 
00411EEB  call        std::vector<int,std::allocator<int> >::size (41159Bh) 
00411EF0  cmp         dword ptr [_Pos],eax 
00411EF3  jb          std::vector<char,std::allocator<char> >::operator[]+10Ch (411F4Ch) 
00411EF5  xor         eax,eax 
00411EF7  jne         std::vector<char,std::allocator<char> >::operator[]+0E4h (411F24h) 
00411EF9  mov         esi,esp 
00411EFB  push        offset string L"("_Pos < size()", 0)"... (41B71Ch) 
00411F00  push        0    
00411F02  push        2F8h 
00411F07  push        offset string L"c:\\program files\\mic"... (41B8B0h) 
00411F0C  push        2    
00411F0E  call        dword ptr [__imp___CrtDbgReportW (41F4D4h)] 
00411F14  add         esp,14h 
00411F17  cmp         esi,esp 
00411F19  call        @ILT+835(__RTC_CheckEsp) (411348h) 
00411F1E  cmp         eax,1 
00411F21  jne         std::vector<char,std::allocator<char> >::operator[]+0E4h (411F24h) 
00411F23  int         3    
00411F24  mov         esi,esp 
00411F26  push        0    
00411F28  push        2F8h 
00411F2D  push        offset string L"c:\\program files\\mic"... (41B8B0h) 
00411F32  push        offset string L"std::vector<char,cla"... (41B778h) 
00411F37  push        offset string L""out of range"" (41B750h) 
00411F3C  call        dword ptr [__imp___invalid_parameter (41F4D8h)] 
00411F42  add         esp,14h 
00411F45  cmp         esi,esp 
00411F47  call        @ILT+835(__RTC_CheckEsp) (411348h) 

		return (*(_Myfirst + _Pos));
00411F4C  mov         eax,dword ptr [this] 
00411F4F  mov         eax,dword ptr [eax+8] 
00411F52  add         eax,dword ptr [_Pos] 
	}

while in release build,

c = vecObj[2];
004011EC  mov         ecx,dword ptr [esp+20h] 
004011F0  cmp         ecx,ebx 
004011F2  je          main+12Bh (4011FBh) 
004011F4  sub         eax,ecx 
004011F6  cmp         eax,2 
004011F9  ja          main+12Dh (4011FDh) 
004011FB  call        ebp

please comment,
Thank you,
Best Regards
Raj

-- modified at 0:54 Tuesday 5th June, 2007

Stephen Hewitt4-Jun-07 19:00

4-Jun-07 19:00

That's because you're looking at the code in a debug build (which means function inlining is disabled). I can also see you've got iterator debugging and range checking enabled. In short your comparison is flawed. Here's a disassembly for a release build (using MSVC6):

For the raw array:

16:       int raw = IntRaw[0];
004010DC   mov         eax,dword ptr [esi]

For the vector:

20:       int vec = IntVec[0];
0040113B   mov         eax,dword ptr [ebp]

Here's the whole program used:

// VectorTest.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <vector>
#include <iostream>
 
int main(int argc, char* argv[])
{
	using namespace std;
 
	int *IntRaw = new int[10];
	vector<int> IntVec(10, 0);
 
	// Raw.
	int raw = IntRaw[0];
	cout << raw << endl;
 
	// Vector.
	int vec = IntVec[0];
	cout << vec << endl;
 
	return 0;
}

Steve

Rajkumar R4-Jun-07 19:18

4-Jun-07 19:18

Hi,
I have posted already the release build disassembly. please check

Stephen Hewitt4-Jun-07 19:29

4-Jun-07 19:29

As I mentioned, you've got iterator range checking enabled. See here[^] for details. Your comparison isn't fair because the raw array isn't doing any range checks. If you define _SECURE_SCL as 0 the range checking will be disabled and the code will be identical.

Steve

Rajkumar R4-Jun-07 19:57

4-Jun-07 19:57

Hi,

if we disabled range checking it affects all STL containers we use .
Yes, the comparison is not fair so i said raw array and vector are different.
This is only a simply operator we have other operators/ interface that have more expensive operations.
A single additional instruction will be neglegible for application which uses it less frequently. IN 3D graphics application, point(vertex) is the building block. Millions of triangle for single 3D object will have 3*Millions of vertex. a single additional instruction will have 3*Million instruction this will reduce the performance.
I repeat I put simple example operator [], but for other interfaces we can't even set
_SECURE_SCL like definition to 0.
Yes STL is best. But I just want to ensure the above statement.

Mr. kevinbrydon may use this application for thousand of triangle today, he may use it for millions of triangle tomorrow.

Best Regards
Raj

Stephen Hewitt4-Jun-07 20:11

set 24 hr time format using Date Time Picker Control

4-Jun-07 20:11

Rajkumar_R wrote:
if we disabled range checking it affects all STL containers we use .

That's exactly what I want to happen in a release build. In my opinion, and that of many others, checked iterators should not be enabled in release builds by default anyway. I use code like this in my precompiled header to get it to work this way:

#ifdef NDEBUG
#define _SECURE_SCL 0
#endif

I encourage you to do this and have another look at the release build's machine code. For most operations a vector's performance will be the same as that of a raw array (as it was in the MSVC6 code I posted). All the member functions are simple inline functions.

Steve

abhiakude4-Jun-07 0:28

abhiakude

4-Jun-07 0:28

I want to set 24 hr time format using Date Time Picker Control not 12 hr time format.Please give information about how to change it.

Re: set 24 hr time format using Date Time Picker Control

Rajkumar R4-Jun-07 0:40