C / C++ / MFC

cmk wrote:

__int32 atomicInc(__int32 *val) {
return (__int32)_InterlockedIncrement((long*)val);
}

Skippums wrote:

I am attempting to write some atomicInc functions that take 16 or 32 bit signed arguments, and call the appropriate _InterlockedIncrement intrinsic function when compiled in Visual Studio 2008.

volatile long m_Lock;
__int32 atomicInc(volatile long * val)
{
	return _InterlockedIncrement(val);
}

int _tmain(int argc, _TCHAR* argv[])
{
	atomicInc(&m_Lock);
	return 0;
}

//Here is the part in main where we call atomicInc

; 13   : 	atomicInc(&m_Lock);

	push	OFFSET ?m_Lock@@3JC			; m_Lock
	call	?atomicInc@@YAHPCJ@Z			; atomicInc
	add	esp, 4

//Here is your atomicInc function:
atomicInc@@YAHPCJ@Z PROC				; atomicInc, COMDAT

; 7    : {

	push	ebp
	mov	ebp, esp
	sub	esp, 64					; 00000040H
	push	ebx
	push	esi
	push	edi

//Now look at all the instructions that are executed before you attempt to atomically increment your variable.
//A context switch CAN take place within this small window your count will NOT be atomic.
//In fact maybe another thread modified it and will cause a deadlock or race condition.
; 8    : 	return _InterlockedIncrement(val);

	mov	eax, DWORD PTR _val$[ebp]
	mov	ecx, 1
	lock	 xadd	 DWORD PTR [eax], ecx
//The line above is the atomic increment instructions.
	inc	ecx
	mov	eax, ecx

; 9    : }

	pop	edi
	pop	esi
	pop	ebx
	mov	esp, ebp
	pop	ebp
	ret	0

//replace colours with black
		if(data[a] == 208)
		{
			data[a] = 75;
			
		}

CClientDC dc(this); // device context for painting

BITMAPINFO bmi; //header stuct

bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth  = 208;
bmi.bmiHeader.biHeight = 208;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 8;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biSizeImage = 0;
bmi.bmiHeader.biXPelsPerMeter = 0;
bmi.bmiHeader.biYPelsPerMeter = 0;
bmi.bmiHeader.biClrUsed = 0;
bmi.bmiHeader.biClrImportant = 0;

CBitmap bitmap;
bitmap.CreateCompatibleBitmap(&dc,208,208); //create 208x208 bitmap
::SetDIBits(dc.m_hDC,bitmap,0,208,rawImageArray,&bmi,DIB_RGB_COLORS);// sets the bits to array
CDC dcMemory;
dcMemory.CreateCompatibleDC(&dc);
CBitmap * pOldBitmap = dcMemory.SelectObject(&bitmap);
dc.StretchBlt(0,0, m_nW,m_nH, &dcMemory, 0,0,208,208 , SRCCOPY);//strechs to size of active x window
dcMemory.SelectObject(pOldBitmap);

CClientDC dc(this); // device context for painting

BITMAPINFO *bmi =  (BITMAPINFO*)new char[sizeof(BITMAPINFO) + sizeof(RGBQUAD)*256];//bitmapinfo struct

bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi->bmiHeader.biWidth  = 176;
bmi->bmiHeader.biHeight = 176;
bmi->bmiHeader.biPlanes = 1;
bmi->bmiHeader.biBitCount = 8;
bmi->bmiHeader.biCompression = BI_RGB;
bmi->bmiHeader.biSizeImage = 0;
bmi->bmiHeader.biXPelsPerMeter = 0;
bmi->bmiHeader.biYPelsPerMeter = 0;
bmi->bmiHeader.biClrUsed = 0;
bmi->bmiHeader.biClrImportant = 0;

//this defines a grey scale image haven't tried it but i assume you can mod this to change colours
//as this is essentially the palette

for (int i = 0; i < 256; i++ )
{
	bmi->bmiColors[i].rgbBlue = i;
	bmi->bmiColors[i].rgbGreen = i;
	bmi->bmiColors[i].rgbRed = i;
	bmi->bmiColors[i].rgbReserved = 0;
}

//create the bitmap itself
CBitmap bitmap;
//size of bitmap
bitmap.CreateCompatibleBitmap(&dc,176,176); //create 208x208 bitmap
//sets the DIBits and appends header
::SetDIBits(dc.m_hDC,bitmap ,0 ,176 ,rawImageData ,bmi/*The magic header*/ , DIB_RGB_COLORS);

CDC dcMemory;
dcMemory.CreateCompatibleDC(&dc);
CBitmap * pOldBitmap = dcMemory.SelectObject(&bitmap);
//this code was written for an active x and this streachs the image to the original size
//m_nW(which is the width) and m_nH( the height ) are the size of the active x from the ondraw
dc.StretchBlt(0,0, m_nW,m_nH, &dcMemory, 0,0,176,176 , SRCCOPY);
dcMemory.SelectObject(pOldBitmap);

char buf[100];
strncpy(buf, pChar, 99);
buf[99] = 0;

char *charArray = new char[100];
char (*temp)[100]((char(*)[100])charArray);

char (&temp)[100](*((char(*)[100])charArray));

template<size_t height, size_t width>
void doSomething(double (&darray)[height][width]) {
    ...
}

int main() {
    const size_t height = 100;
    const size_t width  = 100;
    // The following line will NOT compile, but is used only for illustrative purposes
    double* memBlock2D = mxAlloc(height * width * sizeof(double));
    double (&memArray2D)[height][width](*((double(*)[height][width])memBlock2D));
    doSomething(memArray2D);
    return 0;
}