Forum Programmation.c minimiser l'utilisation du CPU

Posté par xenos le 02 octobre 2006 à 19:57.

Étiquettes : aucune

oct.

2006

salut tout le monde ... et merci d'avoir pris du temp pour lirece message.

j'ai un probleme avec je ne sais pas comment faire pour minimiser l'utilisation du CPU dans mon programme...
j'ai utiliser la fonction sleep(int); puis la fonction usleep(int);
mais l'utilisation du CPU reste trop grande...

je cherche une fonction qui donne la main au systeme et qui attend
sans toure dans la fille d'attente du systeme...
merci pour votre aide



int main(void) {


	int key, i=0;


	FILE *meminfo;


	char value[256];


	struct tm up_time;





	time(&d_time);


	uname(&u_name);


	init_curses();		// initialisation de curses


	bkgd(COLOR_PAIR(1));


	memwin = subwin(stdscr,26,33,0,0);


	box(memwin, ACS_VLINE, ACS_HLINE);


	cpuwin = subwin(stdscr, 10, 30, 0, 33);


	box(cpuwin, ACS_VLINE, ACS_HLINE);


	hddwin = subwin(stdscr, 11, 30, 10, 33);


	box(hddwin, ACS_VLINE, ACS_HLINE);


	sup_info = subwin(stdscr, 5, 30, 21, 33);


	box(sup_info, ACS_VLINE, ACS_HLINE);


	menu_bar();


	set_title();


	create_sub_win();


	refresh();


	while(1) {


		werase(sub_mem);


    	if((meminfo = fopen(PROC_MEM, "r")) != NULL) {


    		while(fgets(value, sizeof(value), meminfo)) {


    		//	while(fscanf(meminfo, "%[^\n]", value)) {


    			if(value[0] != '#') {


					i+=1;


					wmove(sub_mem, i, 1);


                	wprintw(sub_mem, "- %s", value);


				}


			}


			i=0;


        	fclose(meminfo);


		}


		info_sup();


		wrefresh(sub_mem);


		usleep(10000);


	}


	getch();


	delwin(cpuwin);


	delwin(memwin);


	delwin(menubar);


	endwin();


	return 0;


}

# usleep dans la boucle

Posté par Adrien BUSTANY (site web personnel) le 02 octobre 2006 à 21:28. Évalué à 0.

Je ne sais plus si c'est en C, mais il me semble que le usleep dans la boucle ça marche moyen... es-tu sur que ça "sleepe" à chaque fois ?
# sleep/usleep

Posté par NeoX le 02 octobre 2006 à 21:40. Évalué à 0.

je ne suis pas certains que ca fasse baisser ton temps d'usage CPU.

de ce que je me souviens, ca met surtout ton programme en pause.

si tu regardais un mode de programmation en thread avec des files d'attentes...
# RTFM

Posté par Krunch (site web personnel) le 02 octobre 2006 à 21:57. Évalué à 2.

je cherche une fonction qui donne la main au systeme et qui attend sans toure dans la fille d'attente du systeme...
Ca s'appelle sched_yield(2). Mais si ça marche pas avec sleep(3), ça marchera sans doute pas mieux avec sched_yield(2). J'ai pas bien lu ton code mais tu peux utiliser gprof, gdb ou strace pour voir où ton programme passe le plus clair de son temps (sans doute dans la boucle la plus interne) et déplacer la temporisation en conséquence.

Tu peux aussi jeter un oeil à setpriority(2).
pertinent adj. Approprié : qui se rapporte exactement à ce dont il est question.

# minimiser l'utilisation du CPU

Posté par xenos le 02 octobre 2006 à 22:38. Évalué à 1.

bon même avec sched_yield ça ne marche pas !!! :( je poste tout mon code si une personne peut m'aider ... le plus important et dans la fonction int main(void)

#include <stdlib.h>
#include <curses.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>
#include <linux/unistd.h>    /* les macros _syscallX */
#include <linux/kernel.h>    /* pour struct sysinfo  */
#include <sys/utsname.h>
#include <sched.h>

#define ENTER		13
#define ESCAPE		27
#define PROC_MEM	"/proc/meminfo"
#define PROC_CPU	"/proc/"
#define PROC_HDD	"/proc/"
// question forum http://linuxfr.org/forums/19/18977.html
//setpriority(2), sched_yield(2)
WINDOW *menubar, *memwin, *cpuwin, *hddwin, *sup_info;
WINDOW *sub_mem, *sub_cpu, *sub_hdd;
time_t d_time;

struct sysinfo s_info;
struct utsname u_name;

typedef struct {
	int processor;
	char *vendor_id;
	int cpu_family;
	char *model_name;
	float cpu_mhz;
	int cache_size;
	int cpuid_level;
} CPU; 

void init_curses(void) {
	initscr();
	start_color();
	init_pair(1, COLOR_WHITE, COLOR_BLUE);
	init_pair(2, COLOR_BLUE, COLOR_WHITE);
	init_pair(3, COLOR_RED, COLOR_WHITE);
	init_pair(4, COLOR_RED, COLOR_YELLOW);
	init_pair(5, COLOR_GREEN, COLOR_BLUE);
	init_pair(6, COLOR_RED, COLOR_BLUE);
	curs_set(0);
	noecho();
	keypad(stdscr, TRUE);
}

void menu_bar(void) {
	menubar = subwin(stdscr, 1,63, 26,0);
	wbkgd(menubar, COLOR_PAIR(2));
	wattron(menubar, COLOR_PAIR(3));
	waddstr(menubar, "ESC");
	wattroff(menubar, COLOR_PAIR(3));
	waddstr(menubar, " : EXIT |");
	wattron(menubar, COLOR_PAIR(3));
	waddstr(menubar, u_name.sysname);
	wattroff(menubar, COLOR_PAIR(3));
	waddstr(menubar, "|");
	wattron(menubar, COLOR_PAIR(3));
	waddstr(menubar, u_name.machine);
	wattroff(menubar, COLOR_PAIR(3));
	waddstr(menubar, "|");
	wattron(menubar, COLOR_PAIR(3));
	waddstr(menubar, u_name.release);
	wattroff(menubar, COLOR_PAIR(3));
	waddstr(menubar, "| ");
	wprintw(menubar, "%s", ctime(&d_time));
}

void set_title(void) {
	wmove(memwin, 0, 2);
	wattron(memwin, COLOR_PAIR(5));
	waddstr(memwin, "Utilisation de la RAM");
	wattroff(memwin, COLOR_PAIR(5));
	wmove(cpuwin, 0, 2);
	wattron(cpuwin, COLOR_PAIR(5));
	waddstr(cpuwin, "Info CPU");
	wattroff(cpuwin, COLOR_PAIR(5));
	wmove(hddwin, 0, 2);
	wattron(hddwin, COLOR_PAIR(5));
	waddstr(hddwin, "Info Hard Disk Drive");
	wattroff(hddwin, COLOR_PAIR(5));
}

void create_sub_win(void) {
	sub_mem = subwin(memwin, 23, 29, 1, 1);
//	sub_cpu = subwin(cpuwin, 5, 15, 1, 20);
//	box(sub_cpu, ACS_VLINE, ACS_HLINE);
//	sub_hdd = subwin(hddwin, 5, 15, 1, 15);
//	box(sub_hdd, ACS_VLINE, ACS_HLINE);
}

void info_sup(void) {
	sysinfo(&s_info);
	werase(sup_info);
	box(sup_info, ACS_VLINE, ACS_HLINE);
	wmove(sup_info, 1, 1);
	wprintw(sup_info, "- uptime : ");
	wattron(sup_info, COLOR_PAIR(6));
	wprintw(sup_info, "%d", s_info.uptime);
	wattroff(sup_info, COLOR_PAIR(6));
	wprintw(sup_info, " sec");
	wmove(sup_info, 3, 1);
	wprintw(sup_info, "- processus active : ");
	wattron(sup_info, COLOR_PAIR(6));
	wprintw(sup_info, "%d", s_info.procs);
	wattroff(sup_info, COLOR_PAIR(6));
	wrefresh(sup_info);
}

int main(void) {
	int key, i=0;
	FILE *meminfo;
	char value[256];
	struct tm up_time;

	time(&d_time);
	uname(&u_name);
	init_curses();		// initialisation de curses
	bkgd(COLOR_PAIR(1));
	memwin = subwin(stdscr,26,33,0,0);
	box(memwin, ACS_VLINE, ACS_HLINE);
	cpuwin = subwin(stdscr, 10, 30, 0, 33);
	box(cpuwin, ACS_VLINE, ACS_HLINE);
	hddwin = subwin(stdscr, 11, 30, 10, 33);
	box(hddwin, ACS_VLINE, ACS_HLINE);
	sup_info = subwin(stdscr, 5, 30, 21, 33);
	box(sup_info, ACS_VLINE, ACS_HLINE);
	menu_bar();
	set_title();
	create_sub_win();
	refresh();
	// CODE A PLACER DANS UN THREAD
	while(1) {
		werase(sub_mem);
    	        if((meminfo = fopen(PROC_MEM, "r")) != NULL) {
    		        while(fgets(value, sizeof(value), meminfo)) {
    			        if(value[0] != '#') {
					i+=1;
					wmove(sub_mem, i, 1);
                	                wprintw(sub_mem, "- %s", value);
				}
			}
			i=0;
        	fclose(meminfo);
		}
		info_sup();
		wrefresh(sub_mem);
		sched_yield();
	}
	// FIN DU CODE
	getch();
	delwin(cpuwin);
	delwin(memwin);
	delwin(menubar);
	endwin();
	return 0;
}

[^] # Re: minimiser l'utilisation du CPU

Posté par NeoX le 02 octobre 2006 à 23:04. Évalué à -1.

while(1) {
werase(sub_mem);
if((meminfo = fopen(PROC_MEM, "r")) != NULL) {
while(fgets(value, sizeof(value), meminfo)) {
if(value[0] != '#') {
i+=1;
wmove(sub_mem, i, 1);
wprintw(sub_mem, "- %s", value);
}
}
i=0;
fclose(meminfo);
}
info_sup();
wrefresh(sub_mem);
sched_yield();
}

je vais paraitre con mais mais je trouve qu'il y a beaucoup de boucle imbriqué pour juste lire dans le meminfo et envoyer les infos dans submem

avec beaucoup d'instructions (wmove, wprintw) qui doivent prendre du temps.
- [^] # Re: minimiser l'utilisation du CPU
  
  Posté par daggett le 02 octobre 2006 à 23:15. Évalué à 3.
  
  je pense deja qu'il faudrait revenir à un sleep(1) dans la boucle à la place du usleep; usleep(10000) ça n'attend qu'un 1/100e de seconde ! Avec la frequence de scheduling du noyau, c'est à peu près comme ne rien attendre du tout. Et on n'a pas besoin de rafraichir cette info aussi souvent...
  Donc revenir à 1 fois par seconde.
  Ensuite, fermer et rouvrir le fichier à chaque tour, c'est un peu bourrin aussi, mieux vaudrait faire un fopen() une fois avant le while(1), et juste utiliser rewind pour relire depuis le début.

# projet terminer à 50%

Posté par xenos le 03 octobre 2006 à 01:03. Évalué à 1.

Voîla je presente devant vous le résultat de mon éffort et de votre aide Biensûr il reste encor beaucoup à faire . si il y as qulque chose à ajouter ou à modifier ... dite le moi :P MERCI

/*******************************************************************************
merci à  John Doe, Krunch et daggett sur le forum du site http://linuxfr.org/
merci pour leur collaboration.
si ce programme marche même à moitié c'est à cause de leur coup de pouce
un gros coup de pouce il faud bien le dire :-)

	programme codé par xenos : xenos.psy@gmail.com
	le lun, 2 oct 2006
	NOTE : projet en cour de développement
	
	gcc -o cmemstat cmemstat.c -lcurses -lpthread

                                    PAR XENOS; TAMDY Mohamed AMINE
********************************************************************************/

#include <stdlib.h>
#include <curses.h>
#include <time.h>
#include <pthread.h>
#include <unistd.h>
#include <linux/unistd.h>    /* les macros _syscallX */
#include <linux/kernel.h>    /* pour struct sysinfo  */
#include <sys/utsname.h>
#include <sched.h>

#define ENTER		13
#define ESCAPE		27
#define PROC_MEM	"/proc/meminfo"
#define PROC_CPU	"/proc/"
#define PROC_HDD	"/proc/"
// question forum http://linuxfr.org/forums/19/18977.html
//setpriority(2), sched_yield(2)

WINDOW *menubar, *memwin, *cpuwin, *hddwin, *sup_info;
WINDOW *sub_mem, *sub_cpu, *sub_hdd;
time_t d_time;
FILE *meminfo;

struct sysinfo s_info;
struct utsname u_name;

void init_curses(void) {
	initscr();
	start_color();
	init_pair(1, COLOR_WHITE, COLOR_BLUE);
	init_pair(2, COLOR_BLUE, COLOR_WHITE);
	init_pair(3, COLOR_RED, COLOR_WHITE);
	init_pair(4, COLOR_RED, COLOR_YELLOW);
	init_pair(5, COLOR_GREEN, COLOR_BLUE);
	init_pair(6, COLOR_RED, COLOR_BLUE);
	curs_set(0);
	noecho();
	keypad(stdscr, TRUE);
}

void menu_bar(void) {
	menubar = subwin(stdscr, 1,63, 26,0);
	wbkgd(menubar, COLOR_PAIR(2));
	wattron(menubar, COLOR_PAIR(3));
	waddstr(menubar, "ESC");
	wattroff(menubar, COLOR_PAIR(3));
	waddstr(menubar, " : EXIT |");
	wattron(menubar, COLOR_PAIR(3));
	waddstr(menubar, u_name.sysname);
	wattroff(menubar, COLOR_PAIR(3));
	waddstr(menubar, "|");
	wattron(menubar, COLOR_PAIR(3));
	waddstr(menubar, u_name.machine);
	wattroff(menubar, COLOR_PAIR(3));
	waddstr(menubar, "|");
	wattron(menubar, COLOR_PAIR(3));
	waddstr(menubar, u_name.release);
	wattroff(menubar, COLOR_PAIR(3));
	waddstr(menubar, "| ");
	wprintw(menubar, "%s", ctime(&d_time));
}

void set_title(void) {
	wmove(memwin, 0, 2);
	wattron(memwin, COLOR_PAIR(5));
	waddstr(memwin, "Utilisation de la RAM");
	wattroff(memwin, COLOR_PAIR(5));
	wmove(cpuwin, 0, 2);
	wattron(cpuwin, COLOR_PAIR(5));
	waddstr(cpuwin, "Info CPU");
	wattroff(cpuwin, COLOR_PAIR(5));
	wmove(hddwin, 0, 2);
	wattron(hddwin, COLOR_PAIR(5));
	waddstr(hddwin, "Info Hard Disk Drive");
	wattroff(hddwin, COLOR_PAIR(5));
}

void create_sub_win(void) {
	sub_mem = subwin(memwin, 23, 29, 1, 1);
//	sub_cpu = subwin(cpuwin, 5, 15, 1, 20);
//	box(sub_cpu, ACS_VLINE, ACS_HLINE);
//	sub_hdd = subwin(hddwin, 5, 15, 1, 15);
//	box(sub_hdd, ACS_VLINE, ACS_HLINE);
}

void info_sup(void) {
	sysinfo(&s_info);
	werase(sup_info);
	box(sup_info, ACS_VLINE, ACS_HLINE);
	wmove(sup_info, 1, 1);
	wprintw(sup_info, "- uptime : ");
	wattron(sup_info, COLOR_PAIR(6));
	wprintw(sup_info, "%d", s_info.uptime);
	wattroff(sup_info, COLOR_PAIR(6));
	wprintw(sup_info, " sec");
	wmove(sup_info, 3, 1);
	wprintw(sup_info, "- processus active : ");
	wattron(sup_info, COLOR_PAIR(6));
	wprintw(sup_info, "%d", s_info.procs);
	wattroff(sup_info, COLOR_PAIR(6));
	wrefresh(sup_info);
}

void *thread_info(void *x) {
	int i=0;
	char value[256];
	if((meminfo = fopen(PROC_MEM, "r")) != NULL) {
		while(1) {
			werase(sub_mem);	
			while(fgets(value, sizeof(value), meminfo)) {
				if(value[0] != '#') {
					i+=1;
					wmove(sub_mem, i, 1);
					wprintw(sub_mem, "- %s", value);
				}
			}
			rewind(meminfo);
			i=0;
			info_sup();
			wrefresh(sub_mem);
			sleep(1);
			//sched_yield();
		}
	}
}

int main(void) {
	int key=0, i=0;
	struct tm up_time;
	pthread_t thread_id;
	time(&d_time);
	uname(&u_name);
	init_curses();		// initialisation de curses
	bkgd(COLOR_PAIR(1));
	memwin = subwin(stdscr,26,33,0,0);
	box(memwin, ACS_VLINE, ACS_HLINE);
	cpuwin = subwin(stdscr, 10, 30, 0, 33);
	box(cpuwin, ACS_VLINE, ACS_HLINE);
	hddwin = subwin(stdscr, 11, 30, 10, 33);
	box(hddwin, ACS_VLINE, ACS_HLINE);
	sup_info = subwin(stdscr, 5, 30, 21, 33);
	box(sup_info, ACS_VLINE, ACS_HLINE);
	menu_bar();
	set_title();
	create_sub_win();
	refresh();
	//l'appelle du thread

	if(pthread_create(&thread_id, NULL, thread_info, "0") != 0) {
		fprintf(stderr, "Error : Thread error !!!\r\n");
		return EXIT_FAILURE;
	}
	
	do {
		key = getch();
	} while(key != ESCAPE);
	pthread_cancel(thread_id);		// arrêt du thread
	fclose(meminfo);
	delwin(cpuwin);
	delwin(memwin);
	delwin(menubar);
	endwin();
	return EXIT_SUCCESS;
}

# Francais quand tu nous tiens

Posté par peck (site web personnel) le 03 octobre 2006 à 10:52. Évalué à 4.

J'essaie d'éviter de faire des remarques sur les fautes de français, étant donné que j'en fais moi-même suffisament. Mais ici on arrive à un point où je ne peux plus comprendre la phrase.

qui attend sans toure dans la fille

- qui attend son tour dans la fille : pauvre fille
- qui attend cent tours dans la file : ou cent cavaliers sur une ligne
- qui attend que le sang tourne dans la fille : ...
- qui attend s'entoure de filles : ca c'est un dicton qui me plait

Mais bon, peu de choses en rapport direct avec le schmilblick
- [^] # Re: Francais quand tu nous tiens
  
  Posté par xenos le 03 octobre 2006 à 14:39. Évalué à 1.
  
  Merci peck pour les précisions sur les fautes d'ortho ...
  j'écris vraiment sans réflexion, de plus je ne suis pas un français
  
  j'espère dans l'avenir que mon français seras aussi bien que le tien
  merci encore une fois ...
  
  qui attend son tour dans la file
  
  NOTE : je sais faire la différence entre fille et file, là c'était jute que faute de frape
  double frape sur le "l".... pour sans je l'avoue ... j'ai vraiment des problèmes.

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.