예제 #1
0
 void save_old_state(JavaThread* java_thread) {
   _java_thread  = java_thread;
   _is_alive = is_alive(java_thread);
   if (is_alive()) {
     _old_state = java_lang_Thread::get_thread_status(_java_thread->threadObj());
   }
 }
예제 #2
0
파일: life.c 프로젝트: dukelv/csci033
/* Function count_alive_neighbors

   Given a game board, array, and a row and column (row, col), determines the number of surrounding cells that are alive.
   If the cell is not on the game board, prints an error message and terminates the program.


   Input: int     rows  - the number of rows of the game board
          int     cols  - the number of columns of the game board
          int[][] array - the previous generation of the game board, a 2D array of zeros and ones
          int     row   - the row of the cell whose neighbors are being counted
          int     col   - the column of the cell whose neighbors are being counted

   Output: The number of surrounding cells that are alive
 */
int count_alive_neighbors(int rows, int cols, int array[rows][cols], int row, int col) {
    /* First, use an assert statement and call is_in_range to confirm the specified cell is on the game board. */
    assert(is_in_range(rows, cols, row, col));

    /* Then, assuming the assert succeeds:
         Compute and return the number of live neighbors by adding together the results of is_alive for each of
         the 8 surrounding cells.  Since is_alive checks to see if a cell is on the board, you do not need to do so here. */
    int counter = 0;
    int r, c;
    for(r=(row-1); r<=(row+1); r++)

    {
	for(c=(col-1); c<=(col+1); c++)
	{
	    if(is_alive(rows, cols, array, r, c))
	    {
		counter++;
	    }
	}
    }
    if(is_alive(rows, cols, array, row, col))
    {
	counter = counter-1;
    }
    return counter;
}
예제 #3
0
void curr_exe() {
	if (is_alive(CURR_POKEMON) && is_alive(OTHR_POKEMON)) {
		if (is_move(CURR_ACTION)) {
			curr_attack();
		} else {
			curr_switchto();
		}
	}
}
예제 #4
0
파일: job.c 프로젝트: marcomorain/neovim
/// Releases job control resources and terminates running jobs
void job_teardown(void)
{
  // 20 tries will give processes about 1 sec to exit cleanly
  uint32_t remaining_tries = 20;
  bool all_dead = true;
  int i;
  Job *job;

  // Politely ask each job to terminate
  for (i = 0; i < MAX_RUNNING_JOBS; i++) {
    if ((job = table[i]) != NULL) {
      all_dead = false;
      uv_process_kill(&job->proc, SIGTERM);
    }
  }

  if (all_dead) {
    return;
  }

  os_delay(10, 0);
  // Right now any exited process are zombies waiting for us to acknowledge
  // their status with `wait` or handling SIGCHLD. libuv does that
  // automatically (and then calls `exit_cb`) but we have to give it a chance
  // by running the loop one more time
  event_poll(0);

  // Prepare to start shooting
  for (i = 0; i < MAX_RUNNING_JOBS; i++) {
    job = table[i];

    // Still alive
    while (job && is_alive(job) && remaining_tries--) {
      os_delay(50, 0);
      // Acknowledge child exits
      event_poll(0);
      // It's possible that the event_poll call removed the job from the table,
      // reset 'job' so the next iteration won't run in that case.
      job = table[i];
    }

    if (job && is_alive(job)) {
      uv_process_kill(&job->proc, SIGKILL);
    }
  }
  // Last run to ensure all children were removed
  event_poll(0);
}
예제 #5
0
파일: gveejay.c 프로젝트: c0ntrol/veejay
gboolean gveejay_idle(gpointer data)
{
	if(gveejay_running())
	{
		int sync = 0;
		if( is_alive(&sync) == FALSE )
		{
			return FALSE;
		} 
		if( sync )
		{
			if( gveejay_time_to_sync( get_ui_info() ) )
			{
				veejay_update_multitrack( get_ui_info() );
			}
		} else
		{
		//	gveejay_sleep( get_ui_info() );
		}

		update_gveejay();

	}
	if( gveejay_restart() )
	{
		//@ reinvoke 
		if( execvp( cargv[0], cargv ) == -1 )
			veejay_msg(VEEJAY_MSG_ERROR, "Unable to restart");
	}

	return TRUE;
}
예제 #6
0
void observer_list::clear () {
    __TBB_ASSERT( this != &the_global_observer_list, "Method clear() cannot be used on the list of global observers" );
    // Though the method will work fine for the empty list, we require the caller
    // to check for the list emptiness before invoking it to avoid extra overhead.
    __TBB_ASSERT( !empty(), NULL );
    {
        scoped_lock lock(mutex(), /*is_writer=*/true);
        observer_proxy *next = my_head;
        while ( observer_proxy *p = next ) {
            __TBB_ASSERT( p->my_version >= 6, NULL );
            next = p->my_next;
            // Both proxy p and observer p->my_observer (if non-null) are guaranteed
            // to be alive while the list is locked.
            task_scheduler_observer_v3 *obs = p->my_observer;
            // Make sure that possible concurrent observer destruction does not
            // conflict with the proxy list cleanup.
            if ( !obs || !(p = (observer_proxy*)__TBB_FetchAndStoreW(&obs->my_proxy, 0)) )
                continue;
            __TBB_ASSERT( !next || p == next->my_prev, NULL );
            __TBB_ASSERT( is_alive(p->my_ref_count), "Observer's proxy died prematurely" );
            __TBB_ASSERT( p->my_ref_count == 1, "Reference for observer is missing" );
            __TBB_ASSERT( !obs->my_busy_count, "Local observer in an empty arena cannot be marked as busy" );
            store<relaxed>( obs->my_busy_count, interface6::task_scheduler_observer::v6_trait );
#if TBB_USE_ASSERT
            p->my_observer = NULL;
            p->my_ref_count = 0;
#endif /* TBB_USE_ASSERT */
            remove(p);
            delete p;
        }
    }
    while( my_head )
        __TBB_Yield();
}
예제 #7
0
static Audio_instrument_widget *create_audio_instrument_widget(struct Patch *patch, bool set_as_current){
  EditorWidget *editor = static_cast<EditorWidget*>(root->song->tracker_windows->os_visual.widget);
  Audio_instrument_widget *instrument = new Audio_instrument_widget(editor->main_window,patch);
  R_ASSERT_RETURN_IF_FALSE2(instrument!=NULL, NULL);
  
  instrument->_patch_widget->name_widget->setText(patch->name);

  //instruments_widget->tabs->insertTab(instrument, QString::fromLatin1(patch->name), instruments_widget->tabs->count());
  g_instruments_widget->tabs->insertWidget(g_instruments_widget->tabs->count(),instrument);

  // (forgot to take copy)
  if (set_as_current){

    IsAlive is_alive(instrument);
    
    // Schedule this happen a little bit later since setCurrentWidget triggers an eventEvent, which might not work properly before the instrument is finished initializing.
    QTimer::singleShot(g_set_current_delay,[is_alive, instrument]{

        if (!is_alive)
          return;
        
        g_instruments_widget->tabs->setCurrentWidget(instrument);  
        MW_update_all_chips();
      });
    
  }

  instrument->updateWidgets();
  
  return instrument;
}
예제 #8
0
CPUThread::CPUThread(CPUThreadType type, const std::string& name, std::function<std::string()> thread_name)
	: m_id(idm::get_last_id())
	, m_type(type)
	, m_name(name)
{
	start(std::move(thread_name), [this]
	{
		g_tls_current_cpu_thread = this;

		Emu.SendDbgCommand(DID_CREATE_THREAD, this);

		std::unique_lock<std::mutex> lock(mutex);

		// check thread status
		while (joinable() && is_alive())
		{
			CHECK_EMU_STATUS;

			// check stop status
			if (!is_stopped())
			{
				if (lock) lock.unlock();

				try
				{
					task();
				}
				catch (CPUThreadReturn)
				{
					;
				}
				catch (CPUThreadStop)
				{
					m_state |= CPU_STATE_STOPPED;
				}
				catch (CPUThreadExit)
				{
					m_state |= CPU_STATE_DEAD;
					break;
				}
				catch (...)
				{
					dump_info();
					throw;
				}

				m_state &= ~CPU_STATE_RETURN;
				continue;
			}

			if (!lock)
			{
				lock.lock();
				continue;
			}

			cv.wait(lock);
		}
	});
}
예제 #9
0
파일: living.cpp 프로젝트: Ircher/CBoE
void iLiving::apply_status(eStatus which, int how_much) {
	if(!is_alive()) return;
	
	static const std::set<eStatus> allow_negative = {
		// The obvious ones:
		eStatus::BLESS_CURSE, eStatus::HASTE_SLOW,
		// The ones that BoE previously allowed:
		eStatus::POISONED_WEAPON, eStatus::POISON, eStatus::ASLEEP,
		// (Note: Negative levels of sleep can be obtained from the Hyperactivity spell. The other two never go negative.)
		// The additional ones that make sense in the negative:
		eStatus::MAGIC_RESISTANCE, eStatus::DUMB,
	};
	
	int lo = 0, hi = 8;
	
	if(which == eStatus::MARTYRS_SHIELD)
		hi = 10;
	else if(which == eStatus::PARALYZED)
		hi = 5000;
	else if(which == eStatus::FORCECAGE)
		hi = 1000;
	
	if(allow_negative.count(which))
		lo = -hi;
	
	if(which == eStatus::ASLEEP || which == eStatus::DUMB) {
		// No "wrapping" allowed for these effects.
		if(status[which] < 0) hi = 0;
		else if(status[which] > 0) lo = 0;
	}
	
	status[which] = minmax(lo,hi,status[which] + how_much);
}
예제 #10
0
s32 sceKernelWaitThreadEnd(s32 threadId, vm::ptr<s32> pExitStatus, vm::ptr<u32> pTimeout)
{
	sceLibKernel.Warning("sceKernelWaitThreadEnd(threadId=0x%x, pExitStatus=*0x%x, pTimeout=*0x%x)", threadId, pExitStatus, pTimeout);

	const auto thread = idm::get<ARMv7Thread>(threadId);

	if (!thread)
	{
		return SCE_KERNEL_ERROR_INVALID_UID;
	}

	if (pTimeout)
	{
	}

	while (thread->is_alive())
	{
		CHECK_EMU_STATUS;

		std::this_thread::sleep_for(std::chrono::milliseconds(1)); // hack
	}

	if (pExitStatus)
	{
		*pExitStatus = thread->GPR[0];
	}

	return SCE_OK;
}
예제 #11
0
파일: main.c 프로젝트: JonHarder/gameOfLife
void toggle_alive(board b, int h, int w) {
  if(is_alive(b, h, w)) {
    set_alive(b,h, w, false);
  } else {
    set_alive(b,h, w, true);
  }
}
예제 #12
0
파일: fiber.cpp 프로젝트: kotbegemot/tasks
void
fiber::priority( int prio)
{
	if ( ! info_) throw fiber_moved();
	info_->priority = prio;
	if ( is_alive() )
		info_->st->reschedule( get_id() );
}
예제 #13
0
bool Actor::fight(Actor & actor)
{
    int damage = base_damage;
    if (current_weapon != 0) {
        damage += current_weapon->get_damage();
    }

    int opponent_damage = actor.base_damage;
    if (actor.current_weapon != 0) {
        opponent_damage += actor.current_weapon->get_damage();
    }

    std::cout << name() << " initiated a fight with " << actor.name() << " to the death." << std::endl;

    while (is_alive() || actor.is_alive()) {
        if (current_weapon != 0) {
            std::cout << "  " << name() << " hits " << actor.name() << " with " << current_weapon->name() << " for " << damage << " health points" << std::endl;
        } else {
            std::cout << "  " << name() << " hits " << actor.name() << " for " << damage << " health points" << std::endl;
        }

        actor.health -= damage;

        if (!actor.is_alive()) {
            std::cout << name() << " won this fight, " << actor.name() << " is dead." << std::endl;
            controller.kill(actor);
            return true;
        }

        if (actor.current_weapon != 0) {
            std::cout << "  " << actor.name() << " hits " << name() << " with " << actor.current_weapon->name() << " for " << opponent_damage << " health points" << std::endl;
        } else {
            std::cout << "  " << actor.name() << " hits " << name() << " for " << opponent_damage << " health points" << std::endl;
        }

        health -= opponent_damage;

        if (!is_alive()) {
            std::cout << actor.name() << " won this fight, " << name() << " is dead." << std::endl;
            controller.kill(*this);
            return false;
        }
    }

    return false;
}
예제 #14
0
파일: creature.cpp 프로젝트: Ircher/CBoE
void cCreature::restore_sp(int amt) {
	if(!is_alive()) return;
	if(mp >= max_mp) return;
	mp += amt;
	if(mp > max_mp)
		mp = max_mp;
	if(mp < 0) mp = 0;
}
예제 #15
0
void test_is_alive(void)
{
    init_gol(3,3);
// Dead by underpopulation
    TEST_ASSERT_EQUAL_INT(0, is_alive(1, 1, 1));
// Dead by overcrowding
    TEST_ASSERT_EQUAL_INT(0, is_alive(1, 1, 4));
// Dead so still dead
    TEST_ASSERT_EQUAL_INT(0, is_alive(1, 1, 2));

// Alive due born or live
    TEST_ASSERT_EQUAL_INT(1, is_alive(1, 1, 3));
// Alive so still alive
    table[1][1] = 1;
    TEST_ASSERT_EQUAL_INT(1, is_alive(1, 1, 2));

}
예제 #16
0
파일: gc.c 프로젝트: picrin-scheme/benz
static void
gc_sweep_phase(pic_state *pic)
{
  struct heap_page *page;
  int it;
  khash_t(weak) *h;
  khash_t(oblist) *s = &pic->oblist;
  struct symbol *sym;
  struct object *obj;
  size_t total = 0, inuse = 0;

  /* weak maps */
  while (pic->heap->weaks != NULL) {
    h = &pic->heap->weaks->hash;
    for (it = kh_begin(h); it != kh_end(h); ++it) {
      if (! kh_exist(h, it))
        continue;
      obj = kh_key(h, it);
      if (! is_alive(obj)) {
        kh_del(weak, h, it);
      }
    }
    pic->heap->weaks = pic->heap->weaks->prev;
  }

  /* symbol table */
  for (it = kh_begin(s); it != kh_end(s); ++it) {
    if (! kh_exist(s, it))
      continue;
    sym = kh_val(s, it);
    if (sym && ! is_alive((struct object *)sym)) {
      kh_del(oblist, s, it);
    }
  }

  page = pic->heap->pages;
  while (page) {
    inuse += gc_sweep_page(pic, page);
    total += PAGE_UNITS;
    page = page->next;
  }

  if (PIC_PAGE_REQUEST_THRESHOLD(total) <= inuse) {
    heap_morecore(pic);
  }
}
예제 #17
0
 // java_thread is waiting thread being blocked on monitor reenter.
 // Current thread is the notifying thread which holds the monitor.
 static bool wait_reenter_begin(JavaThread *java_thread, ObjectMonitor *obj_m) {
   assert((java_thread != NULL), "Java thread should not be null here");
   bool active  = false;
   if (is_alive(java_thread) && ServiceUtil::visible_oop((oop)obj_m->object())) {
     active = contended_enter_begin(java_thread);
   }
   return active;
 }
예제 #18
0
void arena::close_arena () {
#if !__TBB_STATISTICS_EARLY_DUMP
    GATHER_STATISTIC( dump_arena_statistics() );
#endif
    my_market->detach_arena( *this );
    __TBB_ASSERT( is_alive(my_guard), NULL );
    free_arena();
}
예제 #19
0
double Bug::DecreaseEnergy(double amount) {
  amount = GameObject::DecreaseEnergy(amount);

  if (!is_alive())
    StopEating();

  return amount;
}
예제 #20
0
파일: job.c 프로젝트: Saneyan/neovim
void job_teardown()
{
  // 20 tries will give processes about 1 sec to exit cleanly
  uint32_t remaining_tries = 20;
  bool all_dead = true;
  int i;
  Job *job;

  // Politely ask each job to terminate
  for (i = 0; i < MAX_RUNNING_JOBS; i++) {
    if ((job = table[i]) != NULL) {
      all_dead = false;
      uv_process_kill(&job->proc, SIGTERM);
    }
  }

  if (all_dead) {
    return;
  }

  os_delay(10, 0);
  // Right now any exited process are zombies waiting for us to acknowledge
  // their status with `wait` or handling SIGCHLD. libuv does that
  // automatically (and then calls `exit_cb`) but we have to give it a chance
  // by running the loop one more time
  uv_run(uv_default_loop(), UV_RUN_NOWAIT);

  // Prepare to start shooting
  for (i = 0; i < MAX_RUNNING_JOBS; i++) {
    if ((job = table[i]) == NULL) {
      continue;
    }

    // Still alive
    while (is_alive(job) && remaining_tries--) {
      os_delay(50, 0);
      // Acknowledge child exits
      uv_run(uv_default_loop(), UV_RUN_NOWAIT);
    }

    if (is_alive(job)) {
      uv_process_kill(&job->proc, SIGKILL);
    }
  }
}
예제 #21
0
파일: creature.cpp 프로젝트: Ircher/CBoE
void cCreature::heal(int amt) {
	if(!is_alive()) return;
	if(health >= m_health) return;
	health += amt;
	if(health > m_health)
		health = m_health;
	if(health < 0)
		health = 0;
}
예제 #22
0
thread_base_t::~thread_base_t()
{
	ASSERT(!is_alive());

	if (m_private)
	{
		delete m_private;
		m_private = NULL;
	}
}
/*--------------------------------------------------
 * Start the thread
 *-------------------------------------------------*/
PMThread& PMThread::start()
{
  if( !is_alive())
    run_id = _beginthread( (void(*_Optlink)(void*))launch, NULL, 64*1024, this );

  if( run_id == -1 )
    PM_THROW_CLBERROR();

  return *this;
}
예제 #24
0
파일: conway.c 프로젝트: nullsub/LedMatrix
static uint8_t living_neighbors(uint8_t x, uint8_t y)
{
	uint8_t neighbors = 0;
	if(y > 0) { //above
		//middle
		if(is_alive(x,y-1)) {
			neighbors ++;
		} 
		//left
		if(x > 0) {
			if(is_alive(x-1,y-1)) {
				neighbors ++;
			}
		} 
		//right
		if(x < SIZE_X-1) {
			if(is_alive(x+1,y-1)) {
				neighbors ++;
			}
		} 
	}
	if(y < SIZE_Y-1) { //beneath
		//middle
		if(is_alive(x,y+1)) {
			neighbors ++;
		} 
		//left
		if(x > 0) {
			if(is_alive(x-1,y+1)) {
				neighbors ++;
			}
		} 
		//right
		if(x < SIZE_X-1) {
			if(is_alive(x+1,y+1)) {
				neighbors ++;
			}
		}
	} 
	//left
	if(x > 0) {
		if(is_alive(x-1,y)) {
			neighbors ++;
		}
	} 
	//right
	if(x < SIZE_X-1) {
		if(is_alive(x+1,y)) {
			neighbors ++;
		}
	}
	return neighbors;
}
예제 #25
0
bool ThreadImpl::wait_for_thread_end(const ThreadStruct &ts, int32_t time_out)
{
    if(is_alive(ts) == false)
    {
        return true;
    }

    imp_sleep(time_out);

    return false;
}
예제 #26
0
파일: main.c 프로젝트: JonHarder/gameOfLife
bool alive_at(board b, int x, int y) {
  if(x >= b->width)
    x = 0;
  if(x < 0)
    x = b->width-1;
  if(y >= b->height)
    y = 0;
  if(y < 0)
    y = b->height-1;
  return is_alive(b, y, x);
}
예제 #27
0
 JavaThreadSleepState(JavaThread *java_thread) :
   JavaThreadStatusChanger(java_thread, java_lang_Thread::SLEEPING) {
   if (is_alive()) {
     _stat = java_thread->get_thread_stat();
     _active = ThreadService::is_thread_monitoring_contention();
     _stat->thread_sleep();
     if (_active) {
       _stat->thread_sleep_begin();
     }
   } else {
     _active = false;
   }
 }
예제 #28
0
 JavaThreadBlockedOnMonitorEnterState(JavaThread *java_thread, ObjectMonitor *obj_m) :
   JavaThreadStatusChanger(java_thread) {
   assert((java_thread != NULL), "Java thread should not be null here");
   // Change thread status and collect contended enter stats for monitor contended
   // enter done for external java world objects and it is contended. All other cases
   // like for vm internal objects and for external objects which are not contended
   // thread status is not changed and contended enter stat is not collected.
   _active = false;
   if (is_alive() && ServiceUtil::visible_oop((oop)obj_m->object()) && obj_m->contentions() > 0) {
     _stat = java_thread->get_thread_stat();
     _active = contended_enter_begin(java_thread);
   }
 }
예제 #29
0
 JavaThreadParkedState(JavaThread *java_thread, bool timed) :
   JavaThreadStatusChanger(java_thread,
                           timed ? java_lang_Thread::PARKED_TIMED : java_lang_Thread::PARKED) {
   if (is_alive()) {
     _stat = java_thread->get_thread_stat();
     _active = ThreadService::is_thread_monitoring_contention();
     _stat->monitor_wait();
     if (_active) {
       _stat->monitor_wait_begin();
     }
   } else {
     _active = false;
   }
 }
예제 #30
0
 JavaThreadInObjectWaitState(JavaThread *java_thread, bool timed) :
   JavaThreadStatusChanger(java_thread,
                           timed ? java_lang_Thread::IN_OBJECT_WAIT_TIMED : java_lang_Thread::IN_OBJECT_WAIT) {
   if (is_alive()) {
     _stat = java_thread->get_thread_stat();
     _active = ThreadService::is_thread_monitoring_contention();
     _stat->monitor_wait();
     if (_active) {
       _stat->monitor_wait_begin();
     }
   } else {
     _active = false;
   }
 }