ATL / WTL / STL

I will describe shortly here:
void performFFT(int start, int end, Ipp32fc[] image)
{
	for(int i = start; i < end; i++)
	{
		ippiFFTInv(Image[i])....
		ippiFFTInv(Image[i])....
		ippiFFTFwd(Image[i])....	
	}
}

Source calls method performFFT without cilk_spawn:

	Image[10];
	performFFT(0, 10, Image);

Source calls method performFFT with cilk_spawn: (which is performance decrease 1.5 times)

	Image[10];
	cilk_spawn performFFT(0,5, Image);
	performFFT(5,10,Image);
	cilk_sync;

#ifndef QTDDLLTESTCLASSVARIABLE_H
#define QTDDLLTESTCLASSVARIABLE_H

#include "qtddlltestclassvariable_global.h"

class QTDDLLTESTCLASSVARIABLE_EXPORT qtdDllTestClassVariable
{
public:
	qtdDllTestClassVariable();
	~qtdDllTestClassVariable();
	void Test();
	int testInt;
private:

};

#endif // QTDDLLTESTCLASSVARIABLE_H

#include "qtddlltestclassvariable.h"
#include <qDebug>

cpp file
qtdDllTestClassVariable::qtdDllTestClassVariable()
{

}

qtdDllTestClassVariable::~qtdDllTestClassVariable()
{

}

void qtdDllTestClassVariable::Test()
{
	qDebug() << "started";
	testInt = 5;
	int testInt2 = 5;
        qDebug() << testInt << " after int";
	qDebug() << testInt2 << " after int2";
}

[DllImport(@"..\..\..\Win32\Debug\qtdDllTestClassVariable.dll", CharSet = CharSet.Unicode, EntryPoint = "?Test@qtdDllTestClassVariable@@QAEXXZ")]
        public static extern void Test();

IBuffer^ byteArrayToIBufferPtr(byte *source, int size)
{
	Platform::ArrayReference<uint8> blobArray(source, size);
	IBuffer ^buffer = CryptographicBuffer::CreateFromByteArray(blobArray);
	return buffer;
}

byte* IBufferPtrToByteArray(IBuffer ^buffer)
{
	Array<unsigned char,1U> ^platArray = ref new Array<unsigned char,1U>(256);
	CryptographicBuffer::CopyToByteArray(buffer,&platArray);

	byte *dest = platArray->Data;
	return dest;
}

int DataEncryption::encryptData(EncryptionAlgorithm algo, int keySize, void* srcData, const unsigned int srcSize,
		void*& encData, unsigned int& encSize)
{

	LOG_D(TAG, "encryptData()");

	if(srcData == nullptr)
	{
		LOG_E(TAG,"");
		return DataEncryption::RESULT_EMPTY_DATA_ERROR;
	}
	if(srcSize == 0)
	{
		LOG_E(TAG,"");
		return DataEncryption::RESULT_SIZE_ZERO_ERROR;
	}

	IBuffer^ encrypted;
    IBuffer^ buffer;
    IBuffer^ iv = nullptr;
	String^ algName;
	bool cbc = false;

	switch (algo)
	{
	case DataEncryption::ENC_DEFAULT:
		algName = "AES_CBC";
		cbc = true;
		break;
	default:
		break;
	}

	// Open the algorithm provider for the algorithm specified on input.
    SymmetricKeyAlgorithmProvider^ Algorithm = SymmetricKeyAlgorithmProvider::OpenAlgorithm(algName);

    // Generate a symmetric key.
    IBuffer^ keymaterial = CryptographicBuffer::GenerateRandom((keySize + 7) / 8);
    CryptographicKey^ key;

    try
    {
        key = Algorithm->CreateSymmetricKey(keymaterial);
    }
    catch(InvalidArgumentException^ e)
    {
		LOG_E(TAG,"encryptData(): Could not create key.");
		return DataEncryption::RESULT_ERROR;
    }

    // CBC mode needs Initialization vector, here just random data.
    // IV property will be set on "Encrypted".
    if (cbc)
        iv = CryptographicBuffer::GenerateRandom(Algorithm->BlockLength);

    // Set the data to encrypt. 
	IBuffer ^srcDataBuffer = byteArrayToIBufferPtr(static_cast<byte*>(srcData),256);

    // Encrypt and create an authenticated tag.
    encrypted = CryptographicEngine::Encrypt(key, srcDataBuffer, iv);

	//encData = encrypted;
	byte *bb = IBufferPtrToByteArray(encrypted);
	encData = IBufferPtrToByteArray(encrypted);
	encSize = encrypted->Length;

	return DataEncryption::RESULT_SUCCESS;
}


int DataEncryption::decryptData(EncryptionAlgorithm algo, int keySize, void* encData, const unsigned int encSize,
		void*& decData, unsigned int& decSize)
{
	LOG_D(TAG, "decryptData()");

	if(encData == nullptr)
	{
		LOG_E(TAG,"");
		return DataEncryption::RESULT_EMPTY_DATA_ERROR;
	}
	if(encSize == 0)
	{
		LOG_E(TAG,"");
		return DataEncryption::RESULT_SIZE_ZERO_ERROR;
	}

	IBuffer^ encrypted;
    IBuffer^ decrypted;
    IBuffer^ iv = nullptr;
	String^ algName;
	bool cbc = false;

	switch (algo)
	{
	case DataEncryption::ENC_DEFAULT:
		algName = "AES_CBC";
		cbc = true;
		break;
	default:
		break;
	}

	// Open the algorithm provider for the algorithm specified on input.
    SymmetricKeyAlgorithmProvider^ Algorithm = SymmetricKeyAlgorithmProvider::OpenAlgorithm(algName);

    // Generate a symmetric key.
    IBuffer^ keymaterial = CryptographicBuffer::GenerateRandom((keySize + 7) / 8);
    CryptographicKey^ key;

    try
    {
        key = Algorithm->CreateSymmetricKey(keymaterial);
    }
    catch(InvalidArgumentException^ e)
    {
		LOG_E(TAG,"encryptData(): Could not create key.");
		return DataEncryption::RESULT_ERROR;
    }

    // CBC mode needs Initialization vector, here just random data.
    // IV property will be set on "Encrypted".
    if (cbc)
        iv = CryptographicBuffer::GenerateRandom(Algorithm->BlockLength);

    // Set the data to decrypt. 
	byte *cc = static_cast<byte*>(encData);
	IBuffer ^encDataBuffer = byteArrayToIBufferPtr(cc,256);
    // Decrypt and verify the authenticated tag.
    decrypted = CryptographicEngine::Decrypt(key, encDataBuffer, iv);

	byte *bb = IBufferPtrToByteArray(decrypted);
	decData = IBufferPtrToByteArray(decrypted);

	decSize = decrypted->Length;

	return DataEncryption::RESULT_SUCCESS;
}