コード例 #1
0
static void
getoptions (int argc, char *argv[])
{

  int cc;

  while ((cc = getopt (argc, argv, "hVlf:u:m:C:S:")) != EOF)
    {
      switch (cc)
	{
	case 'C':
	  complete = getinterval (optarg);
	  break;
	case 'S':
	  start = getinterval (optarg);
	  break;
	case 'V':
	  fputs (_LS_VERSION_, stderr);
	  exit (-1);
	case 'f':
	  strcpy (logfile, optarg);
	  break;
	case 'h':
	  usage (argv[0]);
	case 'l':
	  details = 1;
	  break;
	case 'm':
	  getarglist (optarg, hosts, MAX_HOSTS + 1);
	  expandhostnames ();
	  break;
	case 'u':
	  getarglist (optarg, users, MAX_USERS + 1);
	  if (strcmp (users[0], "all") == 0)
	    users[0] = NULL;
	  break;
	case '?':
	default:
	  usage (argv[0]);
	}
    }
}
コード例 #2
0
ファイル: menu.c プロジェクト: yang49/CS350-os161
/*
 * Process a single command.
 */
static
int
cmd_dispatch(char *cmd)
{
	time_t beforesecs, aftersecs, secs;
	uint32_t beforensecs, afternsecs, nsecs;
	char *args[MAXMENUARGS];
	int nargs=0;
	char *word;
	char *context;
	int i, result;

	for (word = strtok_r(cmd, " \t", &context);
	     word != NULL;
	     word = strtok_r(NULL, " \t", &context)) {

		if (nargs >= MAXMENUARGS) {
			kprintf("Command line has too many words\n");
			return E2BIG;
		}
		args[nargs++] = word;
	}

	if (nargs==0) {
		return 0;
	}

	for (i=0; cmdtable[i].name; i++) {
		if (*cmdtable[i].name && !strcmp(args[0], cmdtable[i].name)) {
			KASSERT(cmdtable[i].func!=NULL);

			gettime(&beforesecs, &beforensecs);

			result = cmdtable[i].func(nargs, args);

			gettime(&aftersecs, &afternsecs);
			getinterval(beforesecs, beforensecs,
				    aftersecs, afternsecs,
				    &secs, &nsecs);

			kprintf("Operation took %lu.%09lu seconds\n",
				(unsigned long) secs,
				(unsigned long) nsecs);

			return result;
		}
	}

	kprintf("%s: Command not found\n", args[0]);
	return EINVAL;
}
コード例 #3
0
ファイル: catmouse.c プロジェクト: AdamChit/cs350
static
void
cat_simulation(void * unusedpointer, 
               unsigned long catnumber)
{
  int i;
  unsigned int bowl;
  time_t before_sec, after_sec, wait_sec;
  uint32_t before_nsec, after_nsec, wait_nsec;

  /* avoid unused variable warnings. */
  (void) unusedpointer;
  (void) catnumber;


  for(i=0;i<NumLoops;i++) {

    /* make the cat sleep */
    cat_sleep(CatSleepTime);

    /* choose bowl.  legal bowl numbers range from 1 to NumBowls */
    bowl = ((unsigned int)random() % NumBowls) + 1;

    gettime(&before_sec,&before_nsec);
    cat_before_eating(bowl); /* student-implemented function */
    gettime(&after_sec,&after_nsec);

    /* make the cat eat */
    cat_eat(bowl, CatEatTime, catnumber);

    cat_after_eating(bowl); /* student-implemented function */

    /* update wait time statistics */
    getinterval(before_sec,before_nsec,after_sec,after_nsec,&wait_sec,&wait_nsec);
    P(perf_mutex);
    cat_total_wait_secs += wait_sec;
    cat_total_wait_nsecs += wait_nsec;
    if (cat_total_wait_nsecs > 1000000000) {
      cat_total_wait_nsecs -= 1000000000;
      cat_total_wait_secs ++;
    }
    cat_wait_count++;
    V(perf_mutex);
  }

  /* indicate that this cat simulation is finished */
  V(CatMouseWait); 
}
コード例 #4
0
ファイル: epollx.cpp プロジェクト: 2qif49lt/xhblib
void eplister::mainfunction()
{
    g_log.log(LOG_LV_INFO,"eplister thread come!");
    int ifd = -1;
    sockaddr_in cliaddr;
    socklen_t addrlen = sizeof(cliaddr);

    //overtime handle thread;
	unsigned int uilastcheckalive = getticktime();
    while (isrun())
    {
        ifd = accept(m_listerfd,(sockaddr*)&cliaddr,&addrlen);
        if(ifd != -1)
        {
            g_log.log(LOG_LV_DEBUG,"link in,sock %d.",ifd);
            if (m_pep->bfull(ifd))
            {
                g_log.log(LOG_LV_DEBUG,"link refuse,sock %d.",ifd);
                close(ifd);
            }
            else
            {
               
                m_pep->dispatch(ifd,cliaddr.sin_addr.s_addr,ntohs(cliaddr.sin_port));
            }
        }
        else
        {
            if (errno == EAGAIN || errno == EWOULDBLOCK)
                usleep(1 * 1000);
        }
		if (getinterval(uilastcheckalive,getticktime()) > (MAXDIETIME / 2))
		{
			m_pep->checkalive();
			uilastcheckalive = getticktime();
		}
    }
    g_log.log(LOG_LV_INFO,"eplister thread exit!");
}
コード例 #5
0
    void SpicePosition::init() {
        erract_c("SET", 0, (char*)"IGNORE");

        const char * k = "../cfg/kernels.furnsh";
        furnsh_c(k);

        std::vector<std::string> ks;
        kernels(ks);

        for (std::vector<std::string>::iterator i = ks.begin(); i != ks.end(); i++) {
            getbodies(*i);
        }



        for (BodyConstantsConstIterator it = m_bodies.begin(); it != m_bodies.end(); it++) {
            EphemeridesInterval & interval = m_intervals[(*it)->id()];
            getinterval(ks, (*it)->id(), interval);

            if (it == m_bodies.begin()) {
                m_interval.a = interval.a;
                m_interval.b = interval.b;
            } else {
                m_interval.a = std::max(m_interval.a, interval.a);
                m_interval.b = std::min(m_interval.b, interval.b);
            }
        }

        m_interval.a += 100;
        m_interval.b -= 100;

        char timea[1000], timeb[1000];

        timout_c (m_interval.a, "YYYY ::TDB", sizeof(timea), timea);
        timout_c (m_interval.b, "YYYY ::TDB", sizeof(timeb), timeb);

        erract_c("SET", 0, (char*)"DEFAULT");
    }
コード例 #6
0
ファイル: Stamp2Showtime.cpp プロジェクト: zzilla/Homework
bool Stamp2Showtime::toshowtime(u_int64 timestamp, u_int64& showtime, bool isVirtual, u_int64 sysTime)
{
	double d_showtime;

	getinterval();

	//不使用均匀时间戳算法
	if(! isVirtual)
	{
		// 第一次计算显示时间的话需要设置时间戳到显示时间的转换基准
		if(_isfirst)
		{
			_isfirst = false;
			reset(timestamp, sysTime);	
		}

		d_showtime = _prev_showtime + (timestamp - _prev_timestamp);

		// 如果转换出的显示时间与当前时间差距大于1s会认为时间戳异常,重置转换基准
		//显示时间小于系统时间,时间戳异常,重置转换基准
		u_int64 diff2 = d_showtime > sysTime ? (d_showtime - sysTime) : (sysTime - d_showtime);
		if((diff2 >= 500) || (d_showtime < sysTime))
		{
			reset(timestamp, sysTime);
			//显示时间重置
			d_showtime = _base_showtime;
			LOG(LEVEL_INFO, "*********************** Reset Showtime");
		}

		_prev_timestamp = timestamp;
		showtime = _prev_showtime = d_showtime;
		return true;
	}

	// 获取当前时间
#if 1
	struct timeval tv;
	gettimeofday(&tv, NULL);
	u_int64 nowtime = ((u_int64)tv.tv_sec) * 1000 + tv.tv_usec / 1000;
#else
	struct _timeb tb;
	_ftime(&tb);
	u_int64 nowtime = ((u_int64)tb.time) * 1000 + tb.millitm;
#endif

	// 第一次计算显示时间的话需要设置时间戳到显示时间的转换基准
	if(_isfirst)
	{
		_isfirst = false;
		reset(timestamp, nowtime);	
	}
	
	//按统计到帧间隔计算显示时间
	d_showtime = _prev_showtime + (double)_interval_val/_interval_div;

	//判断延迟情况
	__int64 delay = d_showtime - nowtime;
	if(delay > CACHE_TIME*150/100)
	{
		_adjust_unit = -2;
		_adjust_count = CACHE_TIME*50/100;
	}
	else if(delay < CACHE_TIME*50/100)
	{
		_adjust_unit = 2;
		_adjust_count = CACHE_TIME*50/100/2;
	}
	else if(abs(delay - CACHE_TIME) < 30)
	{
		_adjust_unit = 0;
		_adjust_count = 0;
	}

	//计算显示时间
	if(_adjust_count-- > 0)
	{	
		d_showtime = _prev_showtime + (double)_interval_val/_interval_div + _adjust_unit;
	}
	else
	{
		d_showtime = _prev_showtime + (double)_interval_val/_interval_div;
	}

	// 如果转换出的显示时间与当前时间差距大于1s会认为时间戳异常,重置转换基准
	u_int64 diff2 = d_showtime > nowtime ? (d_showtime - nowtime) : (nowtime - d_showtime);
	if(diff2 >= 500)// || (d_showtime < nowtime))
	{
		reset(timestamp, nowtime);
		//显示时间重置
		d_showtime = _base_showtime;
		LOG(LEVEL_INFO, "*********************** Reset Showtime");
	}
	
	showtime       = d_showtime;

	//LOG(LEVEL_INFO, "showtime=%lld, %lld interval=%d, %d, %d", showtime, (u_int64)_prev_showtime, _interval, _interval_val, _interval_div);

	_prev_showtime = d_showtime;

	return true;
}
コード例 #7
0
ファイル: catmouse.c プロジェクト: AdamChit/cs350
int
catmouse(int nargs,
         char ** args)
{
  int catindex, mouseindex, error;
  int i;
  int mean_cat_wait_usecs, mean_mouse_wait_usecs;
  time_t before_sec, after_sec, wait_sec;
  uint32_t before_nsec, after_nsec, wait_nsec;
  int total_bowl_milliseconds, total_eating_milliseconds, utilization_percent;

  /* check and process command line arguments */
  if ((nargs != 9) && (nargs != 5)) {
    kprintf("Usage: <command> NUM_BOWLS NUM_CATS NUM_MICE NUM_LOOPS\n");
    kprintf("or\n");
    kprintf("Usage: <command> NUM_BOWLS NUM_CATS NUM_MICE NUM_LOOPS ");
    kprintf("CAT_EATING_TIME CAT_SLEEPING_TIME MOUSE_EATING_TIME MOUSE_SLEEPING_TIME\n");
    return 1;  // return failure indication
  }

  /* check the problem parameters, and set the global variables */
  NumBowls = atoi(args[1]);
  if (NumBowls <= 0) {
    kprintf("catmouse: invalid number of bowls: %d\n",NumBowls);
    return 1;
  }
  NumCats = atoi(args[2]);
  if (NumCats < 0) {
    kprintf("catmouse: invalid number of cats: %d\n",NumCats);
    return 1;
  }
  NumMice = atoi(args[3]);
  if (NumMice < 0) {
    kprintf("catmouse: invalid number of mice: %d\n",NumMice);
    return 1;
  }
  NumLoops = atoi(args[4]);
  if (NumLoops <= 0) {
    kprintf("catmouse: invalid number of loops: %d\n",NumLoops);
    return 1;
  }

  if (nargs == 9) {
    CatEatTime = atoi(args[5]);
    if (CatEatTime < 0) {
      kprintf("catmouse: invalid cat eating time: %d\n",CatEatTime);
      return 1;
    }
  
    CatSleepTime = atoi(args[6]);
    if (CatSleepTime < 0) {
      kprintf("catmouse: invalid cat sleeping time: %d\n",CatSleepTime);
      return 1;
    }
  
    MouseEatTime = atoi(args[7]);
    if (MouseEatTime < 0) {
      kprintf("catmouse: invalid mouse eating time: %d\n",MouseEatTime);
      return 1;
    }
  
    MouseSleepTime = atoi(args[8]);
    if (MouseSleepTime < 0) {
      kprintf("catmouse: invalid mouse sleeping time: %d\n",MouseSleepTime);
      return 1;
    }
  }

  if ((NumMice >= INVALID_ANIMAL_NUM) || (NumCats >= INVALID_ANIMAL_NUM)) {
    panic("Trying to use too many cats or mice: limit =  %d\n", INVALID_ANIMAL_NUM);
  }

  kprintf("Using %d bowls, %d cats, and %d mice. Looping %d times.\n",
          NumBowls,NumCats,NumMice,NumLoops);
  kprintf("Using cat eating time %d, cat sleeping time %d\n", CatEatTime, CatSleepTime);
  kprintf("Using mouse eating time %d, mouse sleeping time %d\n", MouseEatTime, MouseSleepTime);

  /* create the semaphore that is used to make the main thread
     wait for all of the cats and mice to finish */
  CatMouseWait = sem_create("CatMouseWait",0);
  if (CatMouseWait == NULL) {
    panic("catmouse: could not create semaphore\n");
  }

  /* initialize our simulation state */
  initialize_bowls();

  /* initialize the synchronization functions */
  catmouse_sync_init(NumBowls);

  /* get current time, for measuring total simulation time */
  gettime(&before_sec,&before_nsec);

  /*
   * Start NumCats cat_simulation() threads and NumMice mouse_simulation() threads.
   * Alternate cat and mouse creation.
   */
  for (catindex = 0; catindex < NumCats; catindex++) {
    error = thread_fork("cat_simulation thread", NULL, cat_simulation, NULL, catindex);
    if (error) {
      panic("cat_simulation: thread_fork failed: %s\n", strerror(error));
    }
    if (catindex < NumMice) {
      error = thread_fork("mouse_simulation thread", NULL, mouse_simulation, NULL, catindex);
      if (error) {
	panic("mouse_simulation: thread_fork failed: %s\n",strerror(error));
      }
    } 
  }
  /* launch any remaining mice */
  for(mouseindex = catindex; mouseindex < NumMice; mouseindex++) {
    error = thread_fork("mouse_simulation thread", NULL, mouse_simulation, NULL, mouseindex);
    if (error) {
      panic("mouse_simulation: thread_fork failed: %s\n",strerror(error));
    }
  }
  
  /* wait for all of the cats and mice to finish before
     terminating */  
  for(i=0;i<(NumCats+NumMice);i++) {
    P(CatMouseWait);
  }

  /* get current time, for measuring total simulation time */
  gettime(&after_sec,&after_nsec);
  /* compute total simulation time */
  getinterval(before_sec,before_nsec,after_sec,after_nsec,&wait_sec,&wait_nsec);
  /* compute and report bowl utilization */
  total_bowl_milliseconds = (wait_sec*1000 + wait_nsec/1000000)*NumBowls;
  total_eating_milliseconds = (NumCats*CatEatTime + NumMice*MouseEatTime)*NumLoops*1000;
  if (total_bowl_milliseconds > 0) {
    utilization_percent = total_eating_milliseconds*100/total_bowl_milliseconds;
    kprintf("STATS: Bowl utilization: %d%%\n",utilization_percent);
  }

  /* clean up the semaphore that we created */
  sem_destroy(CatMouseWait);

  /* clean up the synchronization state */
  catmouse_sync_cleanup(NumBowls);

  /* clean up resources used for tracking bowl use */
  cleanup_bowls();

  if (cat_wait_count > 0) {
    /* some rounding error here - not significant if cat_wait_count << 1000000 */
    mean_cat_wait_usecs = (cat_total_wait_secs*1000000+cat_total_wait_nsecs/1000)/cat_wait_count;
    kprintf("STATS: Mean cat waiting time: %d.%d seconds\n",
             mean_cat_wait_usecs/1000000,mean_cat_wait_usecs%1000000);
  }
  if (mouse_wait_count > 0) {
    /* some rounding error here - not significant if mouse_wait_count << 1000000 */
    mean_mouse_wait_usecs = (mouse_total_wait_secs*1000000+mouse_total_wait_nsecs/1000)/mouse_wait_count;
    kprintf("STATS: Mean mouse waiting time: %d.%d seconds\n",
             mean_mouse_wait_usecs/1000000,mean_mouse_wait_usecs%1000000);
  }

  return 0;
}