Arbeitsspeicher bestimmen

MMueller

Guten Abend,

könnt ihr mir weiterhelfen? Wie kann ich den Arebitsspeicher meines Computers bestimmen? Geht das über einen dynamischen Speicher (malloc)?

Danke

Wutz

Rufe solange malloc(1) in einer Schleife auf, bis malloc NULL liefert.
Das Ergebnis hat nichts mit dem physisch vorhandenem Speicher deines PC zu tun, deine Frage ist ungenau und konfus.

MMueller

ach so. Aber ich erhalte immer 0, wenn ich das eingebe.

#include <stdio.h>
#include <stdlib.h>

int main()
{
void *speicher;

do
{
	speicher = malloc(1);

}
while ( malloc==0);

printf("Speicher ist:%f", speicher); 

	  return 0;
}

Der Formatspecifier für Zeiger ist %p. %f ist für Fließkommazahlen.

Allerdings ist dein Programm nutzlos, etweder nur einmal Speicher angefordert wird (dann ist speicher != NULL) oder ewig (dann ist speicher von Anfang an NULL)

Wutz schrieb:

Das Ergebnis hat nichts mit dem physisch vorhandenem Speicher deines PC zu tun.

Du musst eine Funktion vom Betriebssystem aufrufen. Mit Standard C geht das nicht

Du solltest betriebssystemabhängige Funktionen nutzen, für Windows bspw. GlobalMemoryStatus.

MMueller

aber warum geht das bei c nicht? gibt es keine andere möglichkeit?

MMueller schrieb:

aber warum geht das bei c nicht? gibt es keine andere möglichkeit?

Was verstehst du denn unter "Arbeitsspeicher"? Einem (C-)Programm steht nur ein virtueller Speicher zur Verfügung, der nichts mit dem tatsächlich verfügbaren RAM des Computers zu tun hat (Stichwörter virtueller RAM, swapping, paging).
Beispiel: Ab Windows Vista 64 bit steht einem Programm 8192GB virtueller RAM zu, obwohl der physische RAM längst nicht so groß ist bzw. sein muss. Der theoretische max. Wert von 2^64(/2?) byte wird im Laufe der Zeit immer weiter ausgeschöpft.
Du möchtest Informationen über den Computer im Allgemeinen und benötigst daher os-spezifische Funktionen.

Swordfish

Windows:

#ifndef UNICODE
#define UNICODE
#endif

#ifndef _UNICODE
#define _UNICODE
#endif

#include <locale>
#include <string>
#include <iostream>

#define WIN32_LEAN_AND_MEAN
#define _WIN32_WINNT 0x0501
#define _WIN32_DCOM

#include <windows.h>
#include <wchar.h>
#include <stdio.h>
#include <conio.h>

#include <objbase.h>
#pragma comment( lib, "ole32.lib" )

#include <wbemidl.h>
# pragma comment(lib, "wbemuuid.lib")

template< typename T >
class de_numpunct : public std::numpunct< T > {

	public:
		explicit de_numpunct( std::size_t refs = 0 ) : std::numpunct< T >( refs ) { }

	protected:

		virtual char_type do_decimal_point() const { return TEXT( ',' ); }
		virtual char_type do_thousands_sep() const { return TEXT( '.' ); }
		virtual std::string do_grouping() const { return "\03"; }
};

int WINAPI WinMain( HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmd_line, int show_state )
{
	AllocConsole();

	std::locale locale( std::locale(), new de_numpunct< wchar_t >() );

	std::wcout.imbue( locale );

	HRESULT result = CoInitializeEx( 0, COINIT_MULTITHREADED );

	if( result != S_OK ) {

		std::wcerr << TEXT( "Failed to initialize COM library. Error code = 0x" ) << std::hex << result << std::endl;
		_getch();

		CoUninitialize();
		return EXIT_FAILURE;
	}

	result = CoInitializeSecurity( nullptr, -1, nullptr, nullptr, RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_IMPERSONATE, nullptr, EOAC_NONE, nullptr );

	if( result != S_OK ) {

		std::wcerr << TEXT( "Failed to initialize security. Error code = 0x" ) << std::hex << result << std::endl;
		_getch();

		CoUninitialize();
		return EXIT_FAILURE;
	}

	IWbemLocator *wbem_locator = nullptr;

	result = CoCreateInstance( CLSID_WbemLocator, nullptr, CLSCTX_INPROC_SERVER, IID_IWbemLocator,
		reinterpret_cast< void** >( &wbem_locator ) );

    if( result != S_OK ) {

        std::wcerr << TEXT( "Failed to create IWbemLocator object. Err code = 0x" ) << std::hex << result << std::endl;
		_getch();

		CoUninitialize();
		return EXIT_FAILURE;
    }

	IWbemServices *wbem_services = nullptr;

	result = wbem_locator->ConnectServer( TEXT( "ROOT\\CIMV2" ), nullptr, nullptr, nullptr, 0, nullptr, nullptr, &wbem_services );

	if( result != S_OK ) {

		std::wcerr << TEXT( "Could not connect. Error code = 0x" ) << std::hex << result << std::endl;
		_getch();

		wbem_locator->Release();
		CoUninitialize();
		return EXIT_FAILURE;
	}

	result = CoSetProxyBlanket( wbem_services, RPC_C_AUTHN_WINNT, RPC_C_AUTHZ_NONE, nullptr, RPC_C_AUTHN_LEVEL_CALL, RPC_C_IMP_LEVEL_IMPERSONATE,
		nullptr, EOAC_NONE );

	if( result != S_OK ) {

		std::wcerr << TEXT( "Could not set proxy blanket. Error code = 0x" ) << std::hex << result << std::endl;
		_getch();

		wbem_services->Release();
		wbem_locator->Release();
		CoUninitialize();
		return EXIT_SUCCESS;
	}

	IEnumWbemClassObject* wbem_enumerator = nullptr;
	result = wbem_services->ExecQuery( TEXT( "WQL" ), TEXT( "SELECT * FROM Win32_PhysicalMemory" ),
		WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY, nullptr, &wbem_enumerator );

	if( result != S_OK ) {

		std::wcerr << TEXT( "Query for processes failed. Error code = 0x" ) << std::hex << result << std::endl;
		_getch();

		wbem_services->Release();
		wbem_locator->Release();
		CoUninitialize();
		return EXIT_SUCCESS;

	} 

	IWbemClassObject *wbem_object;
	long unsigned returned = 0;
	long long unsigned memory = 0;

	while( wbem_enumerator ) {

		wbem_enumerator->Next( WBEM_INFINITE, 1, &wbem_object, &returned );

		if( returned != 1 ) break;

		VARIANT prop;

		wbem_object->Get( TEXT( "DeviceLocator" ), 0, &prop, 0, 0 );
		std::wcout << prop.bstrVal;

		wbem_object->Get( TEXT( "Capacity" ), 0, &prop, 0, 0 );

		long long unsigned capacity = 0;
		swscanf( prop.bstrVal, TEXT("%I64d"), &capacity );

		std::wcout << TEXT( ": " ) << capacity << TEXT( " bytes " ) << std::endl;

		memory += ( capacity / 1024. / 1024. );

		VariantClear( &prop );
		wbem_object->Release();
	}     

	std::wcout << TEXT( "\nTotal Memory: " ) << memory << TEXT( " MiB\n" ) << std::endl;

	_getch();

	wbem_services->Release();
	wbem_locator->Release();
	CoUninitialize();

	return EXIT_SUCCESS;
}

//edit: aufräumen vergessen.

Netter Code, aber ich denke nicht dass C weiss was nen Template ist

C/Linux:

#include <stdlib.h>
#include <stdio.h>

int
main(void)
{
        FILE *f;                                                                                                                                    
        int c;

        f = fopen("/proc/meminfo", "r");
        if (f == NULL)
                exit(1);

        while ((c = fgetc(f)) != EOF && c != '\n')
                putchar(c);

        putchar('\n');
        fclose(f);

        return 0;
}