C / C++ / MFC

// async-unwrapping.cpp
// compile with: /EHsc
#include <ppltasks.h>
#include <iostream>

using namespace concurrency;
using namespace std;

int wmain()
{
    auto t = create_task([]()
    {
        wcout << L"Task A" << endl;

        // Create an inner task that runs before any continuation
        // of the outer task.
        return create_task([]()
        {
            wcout << L"Task B" << endl;
        });
    });
  
    // Run and wait for a continuation of the outer task.
    t.then([](task<void>& t3) // or task<void> t3
    {
        wcout << L"Task C" << endl;
        t3.wait(); // or .get()
    }).wait();
}

task<wstring> my_task()
{
    auto s = make_shared<wstring>(L"First value");
    return create_task([s] {
        wcout << *s << endl;
        *s = L"Second value";
        return *s; // It fails because of this.
    }).then([s] {
        wcout << *s << endl;
        *s = L"Third value";
        return *s;
    });
}

Quote:

1>c:\program files (x86)\microsoft visual studio 14.0\vc\include\ppltasks.h(372): error C2338: incorrect parameter type for the callable object in 'then'; consider _ExpectedParameterType or task<_ExpectedParameterType> (see below)
1> c:\program files (x86)\microsoft visual studio 14.0\vc\include\ppltasks.h(402): note: see reference to class template instantiation 'Concurrency::details::_FunctionTypeTraits<_Function,_ReturnType>' being compiled
1> with
1> [
1> _Function=my_task::<lambda_fe524192daf67b16ea75ab49971b7103>,
1> _ReturnType=std::wstring
1> ]
1> c:\vc++\concurrency_program\createtask\source.cpp(41): note: see reference to class template instantiation 'Concurrency::details::_ContinuationTypeTraits<my_task::<lambda_fe524192daf67b16ea75ab49971b7103>,_ReturnType>' being compiled
1> with
1> [
1> _ReturnType=std::wstring
1> ]
1>c:\vc++\concurrency_program\createtask\source.cpp(41): error C2440: 'return': cannot convert from 'Concurrency::task<concurrency::details::_badcontinuationparamtype>' to 'Concurrency::task<std::wstring>'
1> c:\vc++\concurrency_program\createtask\source.cpp(41): note: Constructor for class 'Concurrency::task<std::wstring>' is declared 'explicit'

task<wstring> t1 = create_task([]() {
    wprintf(L"create_task\n");
    return wstring(L"create_task"); // It doesn't throw any error
});

int subSetsFound(int n, int set[], int sum1, int sum2) {
//n is n-1 (sum1 and sum2 are TotalSum/3)
	//cuboid[n][i][j] tells whether first set can have sum i and second - sum j in set = n
	int cuboid[sum1+1][sum2+1][n+1];

	// initialize top row/depth as true
	for (int i = 0; i <= n; i++) {
		cuboid[0][0][i] = 1;
	}

    // initialize two leftmost columns (one in depth), except cuboid[0][0][0] and cuboid[0][1][0], as 0 (false)
    for (int i = 1; i <= sum1; i++) {
    	cuboid[i][0][0] = 0;
    	cuboid[0][i][0] = 0;
    }
//not sure if I should do this
    for (int i = 0; i <= sum1; i++) {
    	for (int j = 1; j <= sum2; j++) {
    		cuboid[0][j][i] = 0;
    	}
    }

    for (int i = 1; i <= sum1; i++) {
		for (int j = 0; j <= sum2; j++) {
			for (int k = 1; k <= n; k++) {
				cuboid[i][j][k] = cuboid[i][j][k-1];
         		if (i - set[k-1] >= 0)
          			cuboid[i][j][k] = cuboid[i][j][k] || cuboid[ j-set[k-1] ] [j] [k-1];
      
				/* This is for 2-sub-set problem
				if (i-S[j-1]) >= 0
	            P(i, j) ← P(i, j-1) или P(i-S[j-1], j-1)
                P(i, j) ← P(i, j-1)
				*/
			}

		}
	}

    return cuboid[sum1][sum2][n];//first set have sum = sum1 and second sum = sum2, so there are two subsets such that the sum is equal

• Standard C (no assembler).
• Can run on "any" microcontroller (of course, it needs to have a certain amount of RAM and flash).
• No use of malloc.
• If running on ARM and there's nothing to do and all timers are turned off, then it should enter stop mode (=system clock is turned off).
• If running on ARM and there's nothing to do but at least one timer is running, then it should enter sleep mode (=some peripherals are turned off, but the system clock and timers are still working).
• Needs to have some sort of prioritization, for example, low-level driver tasks needs to be handled before higher level tasks (such as tasks that arisen due to, for example, a push button pressed event) may be handled.
• It needs to, in some way, support calling of asynchronous functions, such as starting a DMA-transfer and then you get an interrupt when it's finished and in between it should execute other tasks.  

void (*taskFunctionPtr_t)(uint32_t arg1, uint32_t arg2)
enum queueSelector_e {LOW_LEVEL_DRIVERS, USER_EVENTS}; 
addTaskToQueue(taskFunctionPtr_t, queueSelector_e);

while (TRUE) {
    if (0 < numQueuedTasks(LOW_LEVEL_DRIVERS)) {
        handleTask(LOW_LEVEL_DRIVERS);
        continue;
    }
    if (0 < numQueuedTasks(USER_EVENTS)) {
        handleTask(USER_EVENTS);
        continue;
    }
    if (anyTimerRunning()) {
        enterIdleMode();  // System clock is still running, but some peripherals (not the timers!) are turned off
    } else {
        enterStopMode();  // System clock is turned off and can only be woken up user event (external int)
    }
}

void (*asynchronousTaskFinishedFunctionPtr)(asynchronousTaskResult_e);
void someAsynchronousFunction(asynchronousTaskFinishedFunctionPtr); 
enum asyncTaskStatus_e {TASK_NOT_STARTED, TASK_IN_WAIT_PHASE, TASK_FINISHED_NEEDS_REPEAT_DUE_TO_ERROR, TASK_SUCCESSFULLY_FINISHED}; 
asyncTaskStatus_e (*getAsyncTaskStatusPtr)();
addSynchronousTaskToQueue(taskFunctionPtr_t, queueSelector_e);
addAsynchronousTaskToQueue(taskFunctionPtr_t, queueSelector_e, getAsyncTaskStatusPtr);

while (TRUE) {
    Bool_t taskIsInWaitPhase;
    if (0 < numQueuedTasks(LOW_LEVEL_DRIVERS)) {
        taskIsInWaitPhase = handleTask(LOW_LEVEL_DRIVERS);
        if (!taskIsInWaitPhase) {
            continue;
        }
    }
    if (0 < numQueuedTasks(USER_EVENTS)) {
        taskIsInWaitPhase = handleTask(USER_EVENTS);
        if (!taskIsInWaitPhase) {
            continue;
        }
    }
    if (anyTimerRunning() || atLeastOneTaskInWaitPhase()) {
        enterIdleMode();  // System clock is still running, but some peripherals (not the timers!) are turned off
    } else {
        enterStopMode();  // System clock is turned off and can only be woken up user event (external int)
    }
}

// Returns whether the current task is in wait phase or not
Bool_t handleTask(queueSelector_e) {
    if (taskIsAsynchronous()) {
        if (asynchronousTaskStatus == TASK_SUCCESSFULLY_FINISHED) {
            incrementTaskQueueReadPointer();
        } else if ((asynchronousTaskStatus == TASK_NOT_STARTED) || 
                   (asynchronousTaskStatus == TASK_FINISHED_NEEDS_REPEAT_DUE_TO_ERROR)) {
            callTaskFunction();
        } else if (asynchronousTaskStatus == TASK_IN_WAIT_PHASE) {
            // Do nothing
            return TRUE; 
        }
    } else {
        callTaskFunction();
        incrementTaskQueueReadPointer();
    }
    return FALSE;
}

void longTask(uint32_t arg1, uint32_t arg2) {
    enum partSelector_e {
       PART1,
       PART2,
       PART3,
       PART4,
       PART5
    };
    static partSelector_e partSelector = PART1;
    switch (partSelector) {
        case PART1: 
            do1stPartOfLongTask();
            partSelector++;
            repeatThisTask();  // Tell scheduler to repeat this task (scheduler will not increment task queue read ptr)
            return;
        case PART1: 
            do2ndPartOfLongTask();
            partSelector++;
            repeatThisTask();  // Tell scheduler to repeat this task (scheduler will not increment task queue read ptr)
            return;
        case PART3: 
            do3rdPartOfLongTask();
            partSelector++;
            repeatThisTask();  // Tell scheduler to repeat this task (scheduler will not increment task queue read ptr)
            return;
        case PART4: 
            do4thPartOfLongTask();
            partSelector++;
            repeatThisTask();  // Tell scheduler to repeat this task (scheduler will not increment task queue read ptr)
            return;
        case PART5: 
            do5thPartOfLongTask();
            partSelector = PART1;
            return;
    }
}

// This is a task, not an interrupt handler (in the interrupt handler, the following function was added to the USER_EVENTS queue)
void button1pressedTask(uint32_t arg1, uint32_t arg2) {
    readADC();         // Synchronous call, no problem
    setPinHigh();      // Synchronous call, no problem
    startDMAtransfer   // Asynchronous call, MAJOR PROBLEMS!!!! Scheduler needs to able to handle higher priority tasks here!
    writeI2Cdata();    // Synchronous call, no problem
    writeUARTdata();   // Synchronous call, no problem
}