DualCore - Prozess einem Kern zuweisen

[aniram]

ja, hab ich ....

 

[RedWing]

Probiers mal so:

#include <errno.h>
#define __USE_GNU
#include <sched.h>
#undef __USE_GNU

int
main (void)
{
    cpu_set_t set;
    CPU_ZERO(&set);
    CPU_SET(0, &set);
    if (sched_setaffinity(0, sizeof(cpu_set_t), &set) < 0)
        perror("Error in sched_setaffinity()");
    return 0;
}

Gruß,
RedWing

 

[aniram]

sollte klappen,

cpu_1.c:62: error: redefinition of ‘main’
cpu_1.c:10: error: previous definition of ‘main’ was here

jedoch habe ich shcon ne main-funktion

 

[aniram]

Hier mal der ganze Code:

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

volatile int x = 0, y = 0;/* 'volatile' is important! */


pthread_mutex_t x_mutex, y_mutex;


#define ITERATIONS 5000000
/* good value for Athlon 900, eventually adjust for faster/slower processors */
void *thread_routine_0 (void *data) 
{
	int n;
	
	for (n = 0; n < ITERATIONS; n++) {
		pthread_mutex_lock (&x_mutex);
		pthread_mutex_lock (&y_mutex);
		
		x++;
    		y += 2;
		
		pthread_mutex_unlock (&x_mutex);
		pthread_mutex_unlock (&y_mutex);
		}
	return NULL; /* we do not want to return any data */
}

void *thread_routine_1 (void *data)
{
	int n;
	
	for (n = 0; n < ITERATIONS; n++) {
		pthread_mutex_lock (&x_mutex);
		pthread_mutex_lock (&y_mutex);
		
		x++;
    		y += 2;
		
		pthread_mutex_unlock (&x_mutex);
		pthread_mutex_unlock (&y_mutex);
		}
	return NULL; /* we do not want to return any data */
}

int main () {
	pthread_t threads[2];
	int n;
	/* Init mutexes... */
	pthread_mutex_init (&x_mutex, NULL); /* 'NULL' = options (defaults are ok) */
	pthread_mutex_init (&y_mutex, NULL); /* 'NULL' = options (defaults are ok) */
	/* Create threads */
	if (pthread_create (&threads[0], NULL, thread_routine_0, NULL) != 0) 
	{
		puts ("Error creating thread #0!");
		exit (3);
	}
	if (pthread_create (&threads[1], NULL, thread_routine_1, NULL) != 0) 
	{
		puts ("Error creating thread #1!");
		exit (3);
	}
	/* Join the threads (wait until they finished) */
	for (n = 0; n < 2; n++)
		pthread_join (threads[n], NULL);
		/* Cleanup mutexes... */
		pthread_mutex_destroy (&x_mutex);
		pthread_mutex_destroy (&y_mutex);
		/* Print the final values of x and y */
		printf ("x = %i, y = %i\n", x, y);
	return 0;
}

 

[RedWing]

Dann entferne die main Signatur doch und setz den Programmcode am Anfang von DEINER main- Funktion ein. Ein bisschen selber denken hat noch niemanden geschadet ... Entschuldige die blöde Bemerkung
Mich würde intressieren ob das dann so geklappt hat, also halt mich auf dem Laufenden.

Gruß,
RedWing

 

[aniram]

Ging nicht....

cpu_1.c:51: undefined reference to `CPU_ZERO'
cpu_1.c:52: undefined reference to `CPU_SET'


Ich bin jetzt aber andersweitig noch fündig geworden.
http://www.die.net/doc/linux/man/man1/taskset.1.html

Damit geht es, nur habe ich da ein "komisches" Ergebnis festgestellt.
Das Programm lauft auf 2 Kernen doppelt so langsam
Liegt das an der Synchronisation und Overhead, oder wie ist sich das zu erklären?

 

[RedWing]

Ging nicht....

cpu_1.c:51: undefined reference to `CPU_ZERO'
cpu_1.c:52: undefined reference to `CPU_SET'


Ich bin jetzt aber andersweitig noch fündig geworden.
http://www.die.net/doc/linux/man/man1/taskset.1.html

wichtig ist das du sched.h so inkludierst:

#define __USE_GNU
#include <sched.h>
#undef __USE_GNU

da hat das Programm bei mir zumindest kompiliert und auch gelinkt ...

Damit geht es, nur habe ich da ein "komisches" Ergebnis festgestellt.
Das Programm lauft auf 2 Kernen doppelt so langsam
Liegt das an der Synchronisation und Overhead, oder wie ist sich das zu erklären?

Ja ich denke das liegt an der Synchronisation. AFAIK wird ein Programm auf "per Thread" Basis auf beide CPUs vom Kernel verteilt. Deine Synchronisation hat nun folgende Nachteile:
1.) Macht sie die durch den Multicore gewonne echte Parallelität kaputt
2.) Muss Interprozessorkommunikation über einen globalen Speicher (wegen deines Mutex) betrieben werden.

Wieso das das Programm aber gleich DOPPELT so langsam macht, da ja insbesondere auch Punkt 1 im Gegensatz zur Unicoreversion keinen großen Nachteil bringt, weiß ich auch nicht, (evtl. ja (Achtung Mutmaßung ) wegen Ausnutzung von Hypethreading bei Unicorebetrieb).

Gruß,
RedWing

 

[aniram]

Wie könnt ich denn den Code optimieren, dass er auf 2 Kernen schneller läuft?
Oder gibt es hier im Forum Beispiel-Code, die auf DualCores schneller laufen?

Wie funktioniert Multi-Core Programmierung?

 

[RedWing]

Hallo,

Wie könnt ich denn den Code optimieren, dass er auf 2 Kernen schneller läuft?

Dafür gibt es denke kein Patentrezept. Besonders bei deinem Code sieht die Sache kritisch aus, da jeweils beide Threads schreibend auf die Variable zugreifen und somit Synchronisation unumgänglich ist. Es sei denn du willst bewußt nichtdeterministische Raceconditions hervorufen .
Anders sieht die Situation aus wenn du einen Leser und einen Schreiber hast. Da gibt es mehrere Ansätze die je nach Anwendung mehr oder weniger gut passen und die versuchen das Optimum an Parallelität rauszuholen. Stichworte dafür wären:
die Verwendung eines Wechselpuffers, eines Ringpuffers, oder des Frame-Counter Protokolls.

Wie funktioniert Multi-Core Programmierung?

Da kann ich dich leider auch nur in Richtung google verweisen ...

Gruß,
RedWing

 

[aniram]

Hi,
ich habe jetzt vom Prof. ein weiteres Beispiel bekommen. Dort funktioniert es. Ich habe ein Array und berechne die obere und untere Hälfte in jeweils zwei Threads. Hier ist das Progamm ca 1,9x so schnell

Das ganze wollt ich jetzt mit 3 Threads realisieren und zu sehen, wie sich das auf 2 Kerne ausmacht. Verhältnis wäre ja 2:1 oder 1:2 ...

Allerdings läuft es trotzdem doppelt so schnell, was ja normal nicht sein dürfte!?