Пример #1
0
// gcc -o rusage rusage.c -lpsapi
int main(int argc, char **argv)
{
  int const n = atoi(argv[1])*1024*1024;
  int i;
  print_rusage();
  char *a = malloc(n);
  print_rusage();
  for (i = 0; i < n; ++i) a[i] = i;
  print_rusage();
  free(a);
  print_rusage();
}
Пример #2
0
int main (int argc, char *argv[])
{
    struct rlimit rlim;
    pid_t pid = 0;
    int status = 0, nchildren = 3, i;

    /* Print out all limits */

    printf ("Printing out all limits for pid=%d:\n", getpid ());
    print_limits ();

    /* change and printout the limit for core file size */

    printf ("\nBefore Modification, this is RLIMIT_CORE:\n");
    do_limit (RLIMIT_CORE, "RLIMIT_CORE", &rlim);
    rlim.rlim_cur = 8 * 1024 * 1024;
    printf ("I forked off a child with pid = %d\n", (int)pid);

    setrlimit (RLIMIT_CORE, &rlim);
    printf ("\nAfter  Modification, this is RLIMIT_CORE:\n");
    do_limit (RLIMIT_CORE, "RLIMIT_CORE", &rlim);

    /* fork off the nchildren */

    fflush (stdout);
    for (i = 0; i < nchildren; i++) {
        pid = fork ();
        if (pid < 0)
            DEATH ("Failed in fork");
        if (pid == 0) {         /* any child */
            printf ("\nIn child pid= %d this is RLIMIT_CORE:\n",
                    (int)getpid ());
            do_limit (RLIMIT_CORE, "RLIMIT_CORE", &rlim);
            fflush (stdout);
            sleep (3);
            exit (0);
        }
    }

    while (pid > 0) {           /* parent */
        pid = wait (&status);
        printf ("Parent got return on pid=%dn\n", (int)pid);
    }

    printf (" **************************************************** \n");
    print_rusage (RUSAGE_SELF);
    print_rusage (RUSAGE_CHILDREN);

    exit (0);
}
Пример #3
0
static int
printwaitn(struct tcb *tcp, void (*const print_rusage)(struct tcb *, long))
{
	if (entering(tcp)) {
		/* On Linux, kernel-side pid_t is typedef'ed to int
		 * on all arches. Also, glibc-2.8 truncates wait3 and wait4
		 * pid argument to int on 64bit arches, producing,
		 * for example, wait4(4294967295, ...) instead of -1
		 * in strace. We have to use int here, not long.
		 */
		int pid = tcp->u_arg[0];
		tprintf("%d, ", pid);
	} else {
		int status;

		/* status */
		if (tcp->u_rval == 0)
			printaddr(tcp->u_arg[1]);
		else if (!umove_or_printaddr(tcp, tcp->u_arg[1], &status))
			printstatus(status);
		/* options */
		tprints(", ");
		printflags(wait4_options, tcp->u_arg[2], "W???");
		if (print_rusage) {
			/* usage */
			tprints(", ");
			if (tcp->u_rval > 0)
				print_rusage(tcp, tcp->u_arg[3]);
			else
				printaddr(tcp->u_arg[3]);
		}
	}
	return 0;
}
Пример #4
0
void handle_exit(void) {
	syslog(LOG_INFO,"%s:At exit..",__FUNCTION__);
	struct rusage ru;
	if (getrusage(RUSAGE_SELF,&ru) != 0)
		perror("getrusage");
	else 
		print_rusage("",&ru);
}
Пример #5
0
int main (int argc, char **argv)
{
	pid_t pid;
	prusage_t buf;
	int i;

	if (argc == 1) {
		if (getprusage (-1, &buf) == -1)
			err_msg ("getprusage failed");
		print_rusage (getpid (), &buf);
	}
	else {
		for (i = 1; i < argc; i++) {
			pid = atoi (argv [i]);
			if (getprusage (pid, &buf) == -1)
				err_ret ("getprusage failed");
			else
				print_rusage (pid, &buf);
		}
	}

	return (0);
}
Пример #6
0
void print_test_summary(struct timeval *start, struct timeval *stop)
{
    printf("\n");
    printf("%d test%s run, ", test_runs, (test_runs != 1 ? "s" : ""));
    printf("%d success%s, ", test_successes,
            (test_successes != 1 ? "es" : ""));
    printf("%d failure%s", test_failures, (test_failures != 1 ? "s" : ""));

    if(!quiet) {
        printf(", in ");
        print_rusage(start, stop);
    }

    printf(".\n");
}
Пример #7
0
//MAIN
int main(int argc, char **argv) {
	
	//Check the number of arguments to runCommand
	if (argc <= 1) {
		printf("No provided command\n");
		exit(EXIT_FAILURE);
	}
	
	argv[argc]=(char*)NULL;
	
	struct timeval init, end; //checkpoint to measure wall-clock time
	gettimeofday(&init,NULL);
	pid_t pid = fork(); //create a new process
	
	//CHILD
	if (pid == 0) { 
		
		if(execvp(argv[1], &argv[1]) == -1){ //error with de command
			perror(NULL);//print error message
			exit(EXIT_FAILURE);
		}
		
	}else if (pid > 0) { //PARENT
		int status = 0;//return from wait function
		
		wait(&status);//wait for child execution
		gettimeofday(&end,NULL);
		
		//if the child returned EXIT_FAILURE (when something goes wrong)
		if(WEXITSTATUS(status) == EXIT_FAILURE)
			exit(EXIT_FAILURE);
		
		//get child execution statistics
		struct rusage rep;
		getrusage(RUSAGE_CHILDREN,&rep);
		
		//Print report
		printf("\n***REPORT***\n");
		printf("wall-clock:\t\t%d\n",diff_time(init,end));
		print_rusage(rep);
	
	}else { //error
		perror(NULL);//error in fork
		exit(EXIT_FAILURE);
	}
	
	return 0;
}
Пример #8
0
void sigint_handler()
{
	if(end_time_and_usage())
	{
		perror("end_time_and_usage");
		exit(1);
	}
	
	printf("Process statistics : Total packets = %lld\n",mem_info->num_pkts);
	printf("Process statistics : Packets dropped = %lld\n",mem_info->dropped);
	printf("Process statistics : Avg copy time = %f CPU clock cycles\n",(double)(((double)mem_info->copy_time)/(mem_info->num_pkts == 0 ? 1 : mem_info->num_pkts)));

	print_rusage();
	
        exit(0);
}
Пример #9
0
int main (int argc, char **argv)
{
//uint64_t id = 0;      // Can always hold a id_t whatever OSM_ID32

  // CLI options
  int c;
  bool opt_nodes = false;      // Show all nodes
  bool opt_ways  = false;      // Show all ways
  bool opt_relations = false;  // Show all relations
  bool opt_manyrefs = false;   // Show Node having >10 references
  bool opt_reftaged = false;   // Show Node having tags and references
  bool opt_rnnotag = false;    // Show Node having R-ref and no tag

  while ((c = getopt(argc, argv, "nwrmts")) > 0)
    switch (c)
    {
      case 'n' : opt_nodes     = true; break;
      case 'w' : opt_ways      = true; break;
      case 'r' : opt_relations = true; break;
      case 'm' : opt_manyrefs  = true; break;
      case 't' : opt_reftaged  = true; break;
      case 's' : opt_rnnotag   = true; break;
    }
  if (optind != argc-1) return -1;

  osm::OSMData OSM;

  // Restriction a une zone.
  osm::LatLonBox clip;
  clip.open();          // Par defaut, tout prendre


  // Lecture de fichier, chronometree pour test des perfs
  {
    struct timeval prev, curr;
    print_rusage();
    gettimeofday(&prev, NULL);
    OSM.LoadText (argv[optind], clip);
    gettimeofday(&curr, NULL);
    double dur =   (double) (curr.tv_sec - prev.tv_sec)
                 + (double) (curr.tv_usec - prev.tv_usec)/1.0e6;
    printf ("Loaded OSM file in %.3fs\n", dur);
    print_rusage();
  }

  // Liste des noeuds
  if (opt_nodes)
  {
    for (unsigned i = 0; i < OSM.m_nodes.size(); ++i)
    {
      osm::OSMData::Node &p = OSM.m_nodes[i];
      printf ("%10.7f %10.7f  %10I64u  T=%d %s\n",
          p.pos.degLat(), p.pos.degLon(), (uint64_t) p.id(),
          p.tags().count,
          (p.tags().name) ? p.tags().name : "");
    }
    printf ("\n\n");
  }

  // Liste des chemins
  if (opt_ways)
  {
    for (unsigned i = 0; i < OSM.m_ways.size(); ++i)
    {
      osm::OSMData::Way &p = OSM.m_ways[i];
      printf ("%5d %s\n",
          p.nodesIx.size(),
          (p.tags().name) ? p.tags().name : "");
    }
    printf ("\n\n");
  }

  // Liste des relations ayant un nom
  if (opt_relations)
  {
    for (unsigned i = 0; i < OSM.m_relations.size(); ++i)
    {
      osm::OSMData::Relation &p = OSM.m_relations[i];
      if (p.tags().name == NULL) continue;
      printf ("%5d %s\n",
          p.eltIx.size(),
          (p.tags().name) ? p.tags().name : "");
    }
    printf ("\n\n");
  }

  // Bounds
  printf ("#\n");
  printf ("# Lat : %10.7f %10.7f\n", OSM.m_filebound.degMinLat(), OSM.m_filebound.degMaxLat());
  printf ("# Lon : %10.7f %10.7f\n", OSM.m_filebound.degMinLon(), OSM.m_filebound.degMaxLon());


  // Compte compare des elements tagges et non taggees
  unsigned tagN[2] = { 0, 0 };
  for (unsigned i = 0; i < OSM.m_nodes.size(); ++i)
    (tagN[(OSM.m_nodes[i].hasTag()) ? 1 : 0])++;
  unsigned tagW[2] = { 0, 0 };
  for (unsigned i = 0; i < OSM.m_ways.size(); ++i)
    (tagW[(OSM.m_ways[i].hasTag()) ? 1 : 0])++;
  unsigned tagR[2] = { 0, 0 };
  for (unsigned i = 0; i < OSM.m_relations.size(); ++i)
    (tagR[(OSM.m_relations[i].hasTag()) ? 1 : 0])++;

  // Recherche du nombre de noeuds non references
  // + Sert a voir s'il y a frequement ces pertes dans les OSM, pour savoir s'il
  //   est rentable de les supprimer du lecteur
  unsigned *refsN = new unsigned[OSM.m_nodes.size()];
  unsigned *refsW = new unsigned[OSM.m_ways.size()];
  unsigned *refsR = new unsigned[OSM.m_relations.size()];
  unsigned bad1=0, bad2=0, bad3=0, bad4=0, bad5=0, bad6=0, bad7=0;
  for (unsigned i = 0; i < OSM.m_nodes.size();     refsN[i++] = 0);
  for (unsigned i = 0; i < OSM.m_ways.size();      refsW[i++] = 0);
  for (unsigned i = 0; i < OSM.m_relations.size(); refsR[i++] = 0);
  printf ("#\n");
  for (unsigned w = 0; w < OSM.m_ways.size(); w++)      // Node references par les Way
  {
    osm::OSMData::Way &p = OSM.m_ways[w];
    for (unsigned i = 0; i < p.nodesIx.size(); ++i)
    {
      if (p.nodesIx[i] < 0)
        ++bad1;
      else if (p.nodesIx[i] >= (int) OSM.m_nodes.size())
        ++bad2;
      else
      {
        ++(refsN[p.nodesIx[i]]);
      }
    }
  }
  printf ("# Node refs from Way : bad1=%u  bad2=%u\n", bad1, bad2);

  // Nbre de Node references et ayant neanmoins des tags
  unsigned NWTagged = 0;
  for (unsigned n = 0; n < OSM.m_nodes.size(); n++)
  {
    if ((refsN[n] > 0) && (OSM.m_nodes[n].hasTag()))
    {
      ++NWTagged;
      if (opt_reftaged)
        printf ("Node %10I64u has %d refs and %d tags\n",
            (uint64_t) OSM.m_nodes[n].id(), refsN[n],
            OSM.m_nodes[n].tags().count);
    }
  }

  // Histogramme des nombres de references des Node par les Way ... zut.
//std::map<unsigned,unsigned> histoN;

  // Nombre de reference a un Node par les Relation en direct
  unsigned *refRN = new unsigned[OSM.m_nodes.size()];
  for (unsigned i = 0; i < OSM.m_nodes.size(); refRN[i++] = 0);
  for (unsigned r = 0; r < OSM.m_relations.size(); r++)      // Node references par les Relation
  {
    osm::OSMData::Relation &p = OSM.m_relations[r];
    for (unsigned i = 0; i < p.eltIx.size(); ++i)
    {
      int k = p.eltIx[i].ix;
      switch (p.eltIx[i].elt)
      {
        case osm::eltNode :
          if (k < 0) ++bad1; else if (k >= (int) OSM.m_nodes.size()) ++bad2;
          else { ++(refsN[k]); ++refRN[k]; }
          break;
        case osm::eltWay :
          if (k < 0) ++bad3; else if (k >= (int) OSM.m_ways.size()) ++bad4;
          else ++(refsW[k]);
          break;
        case osm::eltRelation :
          if (k < 0) ++bad5; else if (k >= (int) OSM.m_ways.size()) ++bad6;
          else ++(refsR[k]);
          break;
        default : ++bad7;
      }
    }
  }
  printf ("# refs from Rel : bad's %u %u %u %u %u %u %u\n",
      bad1, bad2, bad3, bad4, bad5, bad6, bad7);

  // Node references par un Relation et n'ayant poutant pas de tag (=> quel rendu ?)
  unsigned RNnotag = 0;
  for (unsigned n = 0; n < OSM.m_nodes.size(); n++)
  {
    if ((refRN[n] > 0) && (! OSM.m_nodes[n].hasTag()))
    {
      ++RNnotag;
      if (opt_rnnotag)
        printf ("Node %10I64u has %d R-refs and no tags\n",
            (uint64_t) OSM.m_nodes[n].id(), refRN[n]);
    }
  }

  // Histogramme des nombres de references des Node par les Way ... zut.

  unsigned refN0=0, refN1=0, refN2=0, refN3=0, refN4=0,
           refN5=0, refN6=0, refN7=0, refN8=0, refN9=0;
  for (unsigned i = 0; i < OSM.m_nodes.size(); i++)
  {
//  if (OSM.m_nodes[i].tags ... compter les cas de Node sans tag
    switch (refsN[i])
    {
      case 0 : ++refN0; break; case 1 : ++refN1; break;
      case 2 : ++refN2; break; case 3 : ++refN3; break;
      case 4 : ++refN4; break; case 5 : ++refN5; break;
      case 6 : ++refN6; break; case 7 : ++refN7; break;
      case 8 : ++refN6; break; case 9 : ++refN9; break;
    }
  }
  printf("# Node refs never=%u 1=%u 2=%u 3=%u 4=%u 5=%u 6=%u 7=%u 8=%u 9=%u\n",
      refN0, refN1, refN2, refN3, refN4, refN5, refN6, refN7, refN8, refN9);

  // Stats d'allocation
  printf ("#\n");  //     1234567890 1234567890 1234567890 1234567890 123456 123456
  printf ("#           sz     in-OSM   capacity     no-tag     tagged reftag RNnotg\n");
  printf ("# Node     %3d %10u %10u %10u %10u %6u %6u\n", 
      sizeof(osm::OSMData::Node),
      OSM.m_nodes.size(), OSM.m_nodes.capacity(), tagN[0], tagN[1], NWTagged, RNnotag);
  printf ("# Way      %3d %10u %10u %10u %10u\n",
      sizeof(osm::OSMData::Way),
      OSM.m_ways.size(), OSM.m_ways.capacity(), tagW[0], tagW[1]);
  printf ("# Relation %3d %10u %10u %10u %10u\n",
      sizeof(osm::OSMData::Relation),
      OSM.m_relations.size(), OSM.m_relations.capacity(), tagR[0], tagR[1]);
  printf ("# Tags     %3d\n",
      sizeof(osm::Tags));


  if (opt_manyrefs)
  {
    printf ("\n\n");
    for (unsigned i = 0; i < OSM.m_nodes.size(); i++)
      if (refsN[i] >= 10)
        printf ("Node %I64u has %d refs\n", (uint64_t) OSM.m_nodes[i].id(), refsN[i]);
  }
}
Пример #10
0
//MAIN
int main(int argc, char **argv) {
	
	//mtrace();//to check memory leakage problems
	
	//Initialize prev_rusage with 0 values
	struct rusage prev_rusage;
	getrusage(RUSAGE_CHILDREN,&prev_rusage);
	
	
	char str[129];//input string
	char* cmd_args[32]; //vector of strings (arguments for the shell)
	
	while(1) {
		printf(">");//prompt character
		
		if(fgets(str,129,stdin)==NULL)//EOF or error (to be able to pipe input files)
			break;

		//TODO: check string size
		
		int n_args = args_from_str(str, cmd_args);
		
		//Special cases
		if(n_args==0) {free_args(cmd_args); continue;}//no argument
		if(strcmp(cmd_args[0],"exit") == 0 && n_args == 1) {free_args(cmd_args); break;}//exit command
		if(strcmp(cmd_args[0],"cd") == 0) {//change directory built in command
			if(n_args==1)chdir("/home");//default value (in this case, the current directory)
			else chdir(cmd_args[1]);
			free_args(cmd_args);
			continue;
		}
		
		struct timeval init, end; //checkpoint to measure wall-clock time
		
		gettimeofday(&init,NULL);//get time right before creating the child
		pid_t pid = fork(); //create a new process
		
		//CHILD
		if (pid == 0) { 
			
			if(execvp(cmd_args[0], cmd_args) == -1){ //error with de command
				perror(NULL);//print error message
				//free_args(cmd_args);//free memory allocaded in args_from_cmdline function
				exit(EXIT_FAILURE);
			}

		}else if (pid > 0) { //PARENT
			
			int status = 0;//return from wait function
			
			wait(&status);//wait for child execution
			gettimeofday(&end,NULL);
		
			free_args(cmd_args);//free memory allocaded in args_from_str function
			
			//if the child returned EXIT_FAILURE (when something goes wrong)
			if(WEXITSTATUS(status) == EXIT_FAILURE) {
				//the child print the error
				continue;
				//exit(EXIT_FAILURE);
			}
			//get CHILDREN execution statistics
			struct rusage current_rusage;
			getrusage(RUSAGE_CHILDREN,&current_rusage);
			
			//Print report
			printf("\n***REPORT***\n");
			printf("wall-clock:\t\t%d\n",diff_time(init,end));
			//use the difference to get the measurements of the most recent child
			print_rusage(diff_rusage(current_rusage, prev_rusage));
			
			prev_rusage = current_rusage;//update previous accumulated rusage
		
		}else { //error
			perror(NULL);//error in fork
			free_args(cmd_args);//free memory allocaded in args_from_str function
			exit(EXIT_FAILURE);
		}
		
	}
	
	//free_args(cmd_args);//free memory allocaded in args_from_str function
	return 0;
}