bool Scheduler::NeedChange(unsigned long k) {
int cursor = chg_pts_cursor_;
if (cursor < (int)chg_pts_vec_.size()) {
if (k >= chg_pts_vec_[cursor]) {
ATOMIC_ADD_AND_FETCH(&chg_pts_cursor_, 1);
return true;
}
}
return false;
}
void Scheduler::HandleThreadStart() {
ATOMIC_ADD_AND_FETCH(&curr_num_threads_, 1);
ATOMIC_ADD_AND_FETCH(&total_num_threads_, 1);
if (main_thread_started_) {
// child thread
start_sched_ = true;
if (!delay_) {
int priority = RandomPriority();
SetPriority(priority);
}
} else {
// main thread
if (!delay_) {
SetAffinity(); // force all the threads to be executed on one processor
int priority = RandomPriority();
SetPriority(priority);
}
}
ExecutionControl::HandleThreadStart();
}
void deferred_refdec(pvm_object_storage_t *os)
{
assert(inited);
#if 0
if( os->_ah.refCount > 1 )
{
os->_ah.refCount--;
if( os->_ah.refCount <= 0 )
{
os->_ah.refCount++;
goto long_way;
}
return;
}
#endif
STAT_INC_CNT(DEFERRED_REFDEC_REQS);
if(
( (refdec_put_ptr <= REFDEC_BUFFER_HALF) && (refdec_put_ptr > REFDEC_BUFFER_RED_ZONE ) )
||
( refdec_put_ptr > REFDEC_BUFFER_RED_ZONE+REFDEC_BUFFER_HALF )
)
{
//hal_mutex_lock( &deferred_refdec_mutex );
hal_cond_signal( &start_refdec_cond );
//hal_cond_wait( &end_refdec_cond, &deferred_refdec_mutex );
//hal_mutex_unlock( &deferred_refdec_mutex );
}
//long_way:
// TODO ERROR atomic_add returns not what we assume!
//int pos = atomic_add( (int *)&refdec_put_ptr, 1 );
int pos = ATOMIC_ADD_AND_FETCH( (int *)&refdec_put_ptr, 1 );
// Overflow
if( (pos >= REFDEC_BUFFER_SIZE) || (pos == REFDEC_BUFFER_HALF) )
{
STAT_INC_CNT(DEFERRED_REFDEC_LOST);
// We just loose refdec - big GC will pick it up
return;
}
refdec_buffer[pos] = os;
}
void Scheduler::HandleChange(UINT32 c) {
if (start_sched_) {
unsigned long k = ATOMIC_ADD_AND_FETCH(&total_inst_count_, c);
if (NeedChange(k)) {
if (delay_) {
// inject delay
RandomDelay();
} else {
// change priority
int priority = RandomPriority();
SetPriority(priority);
}
}
}
}
// type is IF_TYPE_LOOPBACK, IF_TYPE_ETHERNET
//int if_register_interface(const char *path, ifnet **_i)
int if_register_interface(int type, ifnet **_i, phantom_device_t *dev)
{
ifnet *i;
//int type;
int err;
ifaddr *address;
i = kmalloc(sizeof(ifnet));
if(!i) {
err = ERR_NO_MEMORY;
goto err;
}
memset(i, 0, sizeof(ifnet));
i->dev = dev;
if(dev != 0 && (i->dev->dops.write == 0 || i->dev->dops.read == 0) )
panic("dev has no read or write!");
/* open the device * /
if(!strcmp(path, "loopback")) {
// the 'loopback' device is special
type = IF_TYPE_LOOPBACK;
i->fd = -1;
} else {
i->fd = sys_open(path, 0);
if(i->fd < 0) {
err = i->fd;
goto err1;
}
// find the device's type
err = sys_ioctl(i->fd, IOCTL_NET_IF_GET_TYPE, &type, sizeof(type));
if(err < 0) {
goto err2;
}
} */
// find the appropriate function calls to the link layer drivers
switch(type) {
case IF_TYPE_LOOPBACK:
i->link_input = &loopback_input;
i->link_output = &loopback_output;
i->mtu = 65535;
break;
case IF_TYPE_ETHERNET:
assert(dev);
i->link_input = ðernet_input;
i->link_output = ðernet_output;
i->mtu = ETHERNET_MAX_SIZE - ETHERNET_HEADER_SIZE;
/* bind the ethernet link address */
address = kmalloc(sizeof(ifaddr));
address->addr.len = 6;
address->addr.type = ADDR_TYPE_ETHERNET;
if( dev->dops.get_address == 0 )
{
err = ERR_NET_GENERAL;
kfree(address);
goto err2;
}
err = dev->dops.get_address(dev, &address->addr.addr[0], 6);
if(err < 0) {
err = ERR_NET_GENERAL;
kfree(address);
goto err2;
}
/*err = sys_ioctl(i->fd, IOCTL_NET_IF_GET_ADDR, &address->addr.addr[0], 6);
if(err < 0) {
kfree(address);
goto err2;
}*/
address->broadcast.len = 6;
address->broadcast.type = ADDR_TYPE_ETHERNET;
memset(&address->broadcast.addr[0], 0xff, 6);
address->netmask.type = ADDR_TYPE_NULL;
if_bind_link_address(i, address);
break;
default:
err = ERR_NET_GENERAL;
goto err1;
}
i->id = ATOMIC_ADD_AND_FETCH(&next_id, 1);
//strlcpy(i->path, path, sizeof(i->path));
i->type = type;
i->rx_thread = -1;
i->tx_thread = -1;
//i->tx_queue_sem = sem_create(0, "tx_queue_sem");
hal_sem_init( &(i->tx_queue_sem), "IF TX sem" );
hal_mutex_init(&i->tx_queue_lock, "IF TX Q");
fixed_queue_init(&i->tx_queue, TX_QUEUE_SIZE);
mutex_lock(&ifhash_lock);
hash_insert(ifhash, i);
mutex_unlock(&ifhash_lock);
// don't need threads for loopback if
if(type != IF_TYPE_LOOPBACK)
{
/* start the rx and tx threads on this interface */
err = if_boot_interface(i);
if(err < 0)
goto err2;
//bootp(i);
}
*_i = i;
return NO_ERROR;
err2:
//sys_close(i->fd);
err1:
kfree(i);
err:
return err;
}
static void udp_endpoint_acquire_ref(udp_endpoint *e)
{
ATOMIC_ADD_AND_FETCH(&e->ref_count, 1);
}
