Für 1-2 Mikrosekunden pausieren

[dowhile]

Hi,

ich möchte einen Emulator für einen Mikrocontroller programmieren.

Der Takt des Controllers liegt bei einem Megaherz und die meisten Instructions brauchen ein oder zwei Maschinenzyklen, d.h. ein oder zwei Mikrosekunden.

Dafür ist mein PC zu schnell - Wie bekomme ich es hin, grob die gleiche Geschwindigkeit wie die des Controllers zu erreichen?
Die Zeit, die der Emulator für die Instruction an sich braucht, ist denke ich vernachlässigbar.

Kann ich das Programm irgendwie über ungefähr diese Zeit pausieren lassen?
Ich nutze Windows und finde kein Adäquat zu nanosleep / usleep. Aber auch wenn es das gibt, habe ich gelesen, dass solche Timer bei so kurzen Zeiten sehr ungenau sind.

[Dr. Coxxy]

[snow]

std::this_thread::sleep_for(std::chrono::microseco nds(1)); schon probiert? Ich weiß nicht mehr, woher ich es habe, aber ich habe gelesen, dass es im Gegensatz zu Sleep() recht präzise sein soll.

[Schlüsselbein]

So eine Genauigkeit kannst du afaik vergessen. Für einen Emulator reicht es doch oft, einfach durchzusteppen bzw. sowieso schneller laufen zu lassen.


Gruß

[Dr. Coxxy]

das was schlüsselbein gesagt hat, normalerweise sollte man kein realtime brauchen.

hab das hier eben zusammengecodet, ka ob das so wirklich läuft:

class FakeSleeper
{
private:
public:
	LARGE_INTEGER Frequency;
	LARGE_INTEGER NeededSteps;
private:
public:
	bool Init();
	void SetSleepTime(UINT NumberOfMicroSeconds);
	void FakeSleep();
};

bool FakeSleeper::Init()
{
	if (QueryPerformanceFrequency(&Frequency)) // PerfomanceCounter supported?
	{
		if (Frequency.QuadPart > 1000000) // Frequency high enough to get diffs ~ 1µSecond?
		{
			return true;
		}
	}
	return false;
}

void FakeSleeper::SetSleepTime( UINT NumberOfMicroSeconds )
{
	NeededSteps.QuadPart = Frequency.QuadPart/(1000000/NumberOfMicroSeconds);
}

void FakeSleeper::FakeSleep()
{
	LARGE_INTEGER A;
	QueryPerformanceCounter(&A);
	LARGE_INTEGER B;
	B.QuadPart = A.QuadPart;
	while (B.QuadPart - A.QuadPart < NeededSteps.QuadPart)
	{
		QueryPerformanceCounter(&B);
	}
}

erzeugt bei mir mit werten >= 3mikrosekunden akzeptable ergebnisse mit folgendem code:

	FakeSleeper Test;

	if (!Test.Init())
	{
		printf("FAIL!\n");
	}
	else
	{
		Test.SetSleepTime(3);
		printf("Testing now:\n");
		LARGE_INTEGER A;
		LARGE_INTEGER B;
		LARGE_INTEGER D;
		LARGE_INTEGER F;
		double Seconds;
		QueryPerformanceFrequency(&F);
		for (UINT i = 0; i < 20; i++)
		{
			QueryPerformanceCounter(&A);
			Test.FakeSleep();
			QueryPerformanceCounter(&B);
			D.QuadPart = B.QuadPart - A.QuadPart;
			Seconds = (1.0/F.QuadPart)*D.QuadPart;
			printf("Time Needed: %.012f\n", Seconds);
		}
	}

eben so hingerotzt, keine garantie für fehler.

EDIT1:
berücksichtigt btw. nicht die zeit für den funktionsaufruf, den check und den return, kann also kumultativ zu ner recht hohen fehlermarge führen.

EDIT2:
und da du kein "echtes" sleep mehr hast wird dir das teil nen cpu kern voll auslasten