„Softwareinterrupt“ programmieren ??

IVIalk

Hallo,

ich suche eine Möglichkeit unter Windows (oder besser Plattformübergreifend) so etwas wie ein „Softwareinterrupt“ zu programmieren.

Ich möchte zwei Programme schreiben wobei das erste das zweite in der Ausführung stoppen soll und eine Funktion in dem zweiten Programm aufrufen soll. Danach soll das zweite Programm an der Stelle der Unterbrechung weiterlaufen.

Unter Linux könnte ich mir vorstellen das man so etwas vielleicht mit Signalen hin bekommt aber unter Windows ??

Bin für jeden Tipp dankbar.

skullyan

Sleep() ?
WaitForSingleObject() ?

IVIalk

Hey skullyan,

ich möchte zwei getrennte Programme(Tasks) keine Threads erstellen, wobei das eine das andere steuern kann. Programm A soll Programm B unterbrechen können und so etwas wie eine ISR ausführen.

Trotzdem danke

skullyan

The WaitForSingleObject function can wait for the following objects:

* Change notification
* Console input
* Event
* Memory resource notification
* Mutex
* Process
* Semaphore
* Thread
* Waitable timer

Hab ich was falsch verstanden?

Ah ok, sowas wie " extern "?

Nee, ich gebs auf, weiß leider nichts dazu. Tut mir leid.

IVIalk

Ich möchte nicht nur auf einen Prozess warten, sondern den in Ausführung befindlichen Prozess B zu einer beliebigen Zeit durch Prozess A stoppen können und dazu auch noch einen Funktion in Prozess B aufrufen. Die Funktion soll abgearbeitet werden und dann soll Prozess B an der gestoppten Stelle weiterlaufen.

Bsp. Prozess B läuft in einer Endlosschleife, Prozess A kann ein Signal an Prozess B schicken, den Prozess B unterbrechen und eine Funktion aufrufen. Nach Ausführung der Funktion sollte sich dann Prozess B wieder in der Endlosschleife laufen.

Ich möchte nicht aus Prozess B pollen müssen (z.B. auf ein Shared Memory). Sondern eigentlich ein Signal schicken aber das scheint unter Windows nicht zu funktionieren.

Ich möchte damit einen Hardwareinterrupt simulieren.

berniebutt

Da hast du ein kleines Problem, das mit der Architektur von Windows zu tun hat. Ein sich aufhängender Prozess (Endlosschleife) sollte von MS inzwischen gelöst sein. Alles weitere machen Nachrichten zwischen den Prozessen.
Keine Ahnung: Macht Windows immer noch kooperatives Multitasking???

Martin Richter

Mal grundsätzlich: Ein Prozess kann schon mehrere Threads haben.
Was heißt also "Endlosschleife"? Das ein Thread, der die Fenster bedient nicht mehr will, oder irgendwas tut was Du nicht weißt?
Was sollen die anderen Threads denn beitte machen, sollen die auch unterbrochen werden?

Was für einen user wie "reagiert nicht" aussieht, heißt für Windows noch lange nicht "reagiert nicht"!

Vieleicht solltest Du Dich, wie berniebutt es schrebt, mal etwas mehr mit der Windows Technologie auseinander setzen.

@berniebutt: kooperatives Multitasking? Windows ab NT hat immer nur Präemptives Multitasking unterstützt und implementiert...

sapero

Das ist sehr einfach mit APC:

Prozess 1 - client

int main()
{
	HWND hwndServerWindow = FindWindow(WC_DIALOG, TEXT("leute ich bin hier"));
	DWORD pid;
	HANDLE hThread;
	PAPCFUNC apcOpenConsole, apcCloseConsole;

	if (!hwndServerWindow)
		return MessageBox(0, TEXT("window not found"), 0, 0);

	hThread = OpenThread(MAXIMUM_ALLOWED, FALSE,
		GetWindowThreadProcessId(hwndServerWindow, &pid));

	if (!hThread)
		return MessageBox(0, TEXT("OpenThread error"), 0, 0);

	apcOpenConsole = (PAPCFUNC)SendMessage(hwndServerWindow,
		WM_APP/*get function pointer*/, 0, 0/*index*/);

	apcCloseConsole = (PAPCFUNC)SendMessage(hwndServerWindow,
		WM_APP/*get function pointer*/, 0, 1/*index*/);

	if (apcOpenConsole) {
		QueueUserAPC(apcOpenConsole, hThread, 0/*parameter*/);
		if (apcCloseConsole) {
			Sleep(1000);
			QueueUserAPC(apcCloseConsole, hThread, 0/*parameter*/);
		}
	}

	CloseHandle(hThread);
	return 0;
}

Prozess 2 (server)

void __stdcall apcOpenConsole(ULONG_PTR parameter) // APC dispatch 1
{
	MessageBeep(MB_ICONINFORMATION);
	AllocConsole();
}
void __stdcall apcCloseConsole(ULONG_PTR parameter) // APC dispatch 2
{
	MessageBeep(MB_ICONQUESTION);
	FreeConsole();
}

BOOL __stdcall MainDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
		case WM_APP: {// get function pointer
			static PAPCFUNC addresses[] = {apcOpenConsole, apcCloseConsole};
			if (lParam >= (sizeof(addresses)/4)) return 0;

			SetWindowLong(hwnd, DWL_MSGRESULT, (LONG)addresses[lParam]);
			return TRUE;
			break;
		}
		case WM_CLOSE:
			DestroyWindow(hwnd);
	}
	return FALSE;
}

int WinMain(...)
{
	HWND hwnd = CreateWindow(WC_DIALOG, TEXT("leute ich bin hier"), WS_OVERLAPPEDWINDOW|WS_VISIBLE,0,0,0,0,0,0,0,0);
	HANDLE hEvent = CreateEvent(0,0,0,0);
	SetWindowLong(hwnd, DWL_DLGPROC, (LONG)MainDlgProc);

	while (IsWindow(hwnd))
	{
		switch (MsgWaitForMultipleObjectsEx(1, &hEvent, INFINITE, QS_ALLINPUT, MWMO_ALERTABLE)) // APC enabled
		{
			case 1: { // message in thread queue
				MSG msg;
				while (PeekMessage(&msg, 0, 0, 0, PM_REMOVE))
				{
					if (!IsDialogMessage(hwnd, &msg))
					{
						TranslateMessage(&msg);
						DispatchMessage(&msg);
					}
				}
			}
		}
	}
	CloseHandle(hEvent);
	return 0;
}

berniebutt

Martin Richter schrieb:

@berniebutt: kooperatives Multitasking? Windows ab NT hat immer nur Präemptives Multitasking unterstützt und implementiert...

Ist egal, wie man das nennt. Multitasking mit Zeitscheiben - wie man es vorher von Grossrechnern kannte - ist es jedenfalls nicht. Ist nicht ganz einfach zu verstehen, wie Windows das genau macht.

Mmacher

berniebutt schrieb:

Ist egal, wie man das nennt. Multitasking mit Zeitscheiben - wie man es vorher von Grossrechnern kannte - ist es jedenfalls nicht. Ist nicht ganz einfach zu verstehen, wie Windows das genau macht.

Häh? Das kann ich so nicht bestätigen.
Alle "moderneren" Windows-Systeme von Windows 95 bis Windows Me und von Windows NT bis heute Windows 7 sind Multitasking-Betriebssysteme auf Zeitscheiben-Basis.
Dieses System nennt man auch preemptives Multitasking.

Die andere Sorte von Mutlitasking, nämlich kooperatives Multitasking, war mal beim Vorgänger Windows 3.x und älter gewesen. Wie der Name schon sagt, müssen hierbei alle laufenden Prozesse schnellstmöglich CPU-Ressourcen an andere Prozesse wieder freigeben.

Alles klar?
Martin