zplay donne lui ton programme magique pour qu'il comprenne ce que ca fait.

bonjour,

1) c'est linux et non windows

2) linux utilise toute la mémoire et la libére si nécessaire !

Quel programme?

au passage, comment on fait le petit trait vertical ?

Et se scripte il marche en simple utilisateur ou il faut être en root forcément pour qu'il marche ??

oki par ce que c'est quand même super insécuritaire...
sa veut dire que n'importe qui ayant accès a un compte simple utilisateur peut mettre en croie un poste... même un serveur...

essais "ulimit -u 256" selon "ulimit -a". C'est drôle, j'ai pas la page de manuel, je sais que c'est un 'built-in' du shell, il doit y avoir une description dans la page de mauel de 'bash' parex...

Idéalement à mettre dans /etc/bash.bashrc, voir ~/.bashrc, ou plutôt dans le script de démarrage du shell en question.

/* compilé avec "gcc thread.c -Wall -std=c99 -D_GNU_SOURCE -pedantic -o thread.x -lpthread" */
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

struct thread_node {
long rank;
pthread_t thread;
struct thread_node *prev, *next;
} root, *current, *last;

void *simple_func (void *arg) {
printf ("this is the called function\n");
return NULL;
}

void start_new_thread (struct thread_node *node) {
printf ("thread #%d created\n", node->rank);
pthread_create (&node->thread, NULL, simple_func, NULL);
pthread_join (node->thread, NULL);
}

void init_tree (void) {
root.rank = 1;
root.prev = NULL;
root.next = NULL;

current = &root;
last = &root;

start_new_thread (&root);
}

void destroy_tree (void) {
current = last;
printf ("free'ing ");
while (current->rank > 1) {
printf ("#%d, ", current->rank);
current = current->prev;
current->next->prev = NULL;
if (current->next->next) free (current->next->next);
}
printf ("\n");
}

void add_some_node (long count) {
current = last;
long x;
for (x = 0; x < count; x++) {
current->next = malloc (sizeof (root) );
current->next->rank = current->rank+1;
current->next->prev = current;
current = current->next;
current->next = NULL;
start_new_thread (current);
}
last = current;
}

int main (void) {
printf ("** test pour savoir si les thread sont considéré\n");
printf ("** comme des processus par ulimit\n");

/* pthread_t thread1; */
/* pthread_t thread2; */
/* pthread_attr_t *thr_attr; */

/* pthread_attr_init (thr_attr); */
/* pthread_create (&thread1, NULL, simple_func, NULL); */
/* pthread_join (thread1, NULL); */

init_tree ();
add_some_node (7);

long wanted = 1;
char *str = malloc (256);
while (wanted != 0) {
printf ("\n\nHow many threads to create?\n");
printf ("Give 0 to quit\n");
fgets (str, 255, stdin);
wanted = atoi (str);
add_some_node (wanted);
}
free (str);
destroy_tree ();

return 0;
}

J'ai écrit un programme pour voir ça, et les threads sont pas compté comme processus, du moins, dece que rapporte 'ps -e'

voilà le code pour ceux que ça interesse...



Peut-être que le nombre de threads peut être contôlé avec l'option "stack size" (-s) de ulimit, puisque les threads reproduisent le stack du programme appellant si je me rappel bien (fork() lui reproduit le stack et la plage de mémoire.

[Le N@in Vert:]c'est du croisements entre du C et du C++ ton truc...
"->" sa existe pas en C si ??

[Zplay:]Depuis quand on déclare des variables en plein milieu en C ?

Oui-oui, ça représente que le conteneur, de la variable de droite, est un pointeur. structure/pointeur -> membre;

Il y a 2 types d'accès aux membres, techniquement similaires:
structre.membre; et structure->membre
Le '.' est utilisé pour les structures déclarée comme:
struct conteneur {} copie_conteneur;
Le '->' lui pour:
struct conteneur {} *pointeur_conteneur;

Les copies ont une place bien à elles dans la mémoire. Les pointeurs sont des références de copie, voir de pointeurs, et/ou sont des adresses alloués au besoin.

[esselfe:]Les copies ont une place bien à elles dans la mémoire. Les pointeurs sont des références de copie, voir de pointeurs, et/ou sont des adresses alloués au besoin.

[Le N@in Vert:]D'accord j'apprends un truc...
Moi je croyait qu'il y avait que les '.'
Merci

[freeman37:]oui je veux que sa explose :D

faites comme moi, un burning test de deux jours sans ventilo de processeur

[Le N@in Vert:]Oh la ram sa crame bien mieux qu'un cpu bien au contraire :D

Ah bon