Пример #1
0
void test_resize(){
  ArrayUtil util = create(4, 5);
  int * list_array = (int *)(util.base);
  list_array[0] = 10;
  list_array[1] = 20;
  list_array[2] = 30;
  list_array[3] = 40;
  list_array[4] = 50;

  assert(util.length == 5);
  ArrayUtil resized_util = resize(util, 7);
  assert(resized_util.length = 7);

  int * resized_list_array = (int *)(resized_util.base);
  assert(resized_list_array[4] == 50);
  assert(resized_list_array[5] == 0);
  assert(util.length == 5);

  assert(list_array[4] == 50);

  printf("Array element is not changed\n");

  dispose(util);
}
Пример #2
0
ev_err_t ev_vbuff_set_capacity(ev_vbuff *v, size_t num_bytes)
{
    if( v && num_bytes ) {
        if( v->size < num_bytes ) {
            dispose(v);
        }

        glGenBuffers(1, &v->id);
        if( !v->id )
            return EV_FAIL;

        ev_vbuff_bind(v);

        v->buff = ev_malloc(num_bytes);
        if(!v->buff)
            return EV_NOMEM;

        memset(v->buff, 0, num_bytes);
        glBufferData( GL_ARRAY_BUFFER, num_bytes, v->buff, GL_DYNAMIC_DRAW);
        v->size = num_bytes;
        return EV_OK;
    }
    return EV_FAIL;
}
void AspModel::initFromFile(std::string filename, const uint32_t importFlags)
{
	if (filename.empty())
	{
		SiegeThrow(Exception, "No filename provided for AspModel::initFromFile()!");
	}

	std::ifstream file;
	if (!utils::filesys::tryOpen(file, filename, std::ifstream::binary))
	{
		SiegeThrow(Exception, "Failed to open ASP file \""
				<< filename << "\": '" << utils::filesys::getLastFileError() << "'.");
	}

	size_t fileSizeBytes = 0;
	utils::filesys::queryFileSize(filename, fileSizeBytes);
	if (fileSizeBytes == 0)
	{
		SiegeWarn("ASP file \"" << filename << "\" appears to be empty...");

		// Make this an empty model.
		// NOTE: Should this be changed to an error instead?
		dispose();
		srcFileName = std::move(filename);
		return;
	}

	ByteArray fileContents(fileSizeBytes);
	if (!file.read(reinterpret_cast<char *>(fileContents.data()), fileContents.size()))
	{
		SiegeThrow(Exception, "Failed to read " << utils::formatMemoryUnit(fileContents.size())
				<< " from ASP mode file \"" << filename << "\"!");
	}

	initFromMemory(std::move(fileContents), importFlags, std::move(filename));
}
Пример #4
0
static int set_ttydev(struct cfgdata_t *cfgdata, char *value)
{
	const char str_dev[] = "/dev/";
	char *p;

	/* Check value for 'tty[0-9]' */
	if ( ! ( ('t' == value[0]) && ('t' == value[1]) && ('y' == value[2]) &&
			(value[3] > '0') && (value[3] < '9') )
	) return 0;

	/* Prepend '/dev/' to tty name (value) */
	p = malloc(sizeof(str_dev)+strlen(value));
	if (NULL == p) {
		DPRINTF("Can't allocate memory to store tty device name '/dev/%s'", value);
		return -1;
	}

	dispose(cfgdata->ttydev);
	cfgdata->ttydev = p;
	strcpy(cfgdata->ttydev, str_dev);
	strcat(cfgdata->ttydev, value);

	return 0;
}
CL_GL1FrameBufferProvider::~CL_GL1FrameBufferProvider()
{
	dispose();
	CL_SharedGCData::remove_disposable(this);
}
Пример #6
0
 DocumentSourceCursor::~DocumentSourceCursor() {
     dispose();
 }
Пример #7
0
MWInfoPage::~MWInfoPage()
{
	dispose();
}
WorkerContextExecutionProxy::~WorkerContextExecutionProxy()
{
    dispose();
}
Пример #9
0
Viewport::~Viewport()
{
	dispose();
}
Пример #10
0
 virtual ~MPSegment(){dispose();};
Пример #11
0
SpatialReference::~SpatialReference()
{
	dispose();
}
	InputDeviceProvider_Win32Hid::~InputDeviceProvider_Win32Hid()
	{
		dispose();
	}
Пример #13
0
	SpriteNumber::~SpriteNumber(){
		dispose();
	}
Пример #14
0
/* ### Pack: this routine has changed */
static	int	Send_new_packets( int num_allowed )
{
	packet_header	*pack_ptr;
	scatter	        *scat_ptr;
	int		pack_entry;
	int		num_sent;
	int		ret;

	num_sent = 0;
        while( num_sent < num_allowed )
        {
		/* check if down queue is empty */
		if( Down_queue_ptr->num_mess == 0 ) break;

		/* initialize packet_header */
                pack_ptr =  new(PACK_HEAD_OBJ);

		scat_ptr = Down_queue_ptr->first->mess;

                pack_ptr->type = Down_queue_ptr->first->type;
                pack_ptr->proc_id = My.id;
                pack_ptr->memb_id = Memb_id();
                pack_ptr->seq = Highest_seq+1;
                Highest_seq++;
                pack_ptr->fifo_seq = Highest_fifo_seq+1;
		Highest_fifo_seq++;
                pack_ptr->data_len = scat_ptr->elements[
				Down_queue_ptr->cur_element].len;

                Send_pack.elements[1].buf = scat_ptr->elements[
					Down_queue_ptr->cur_element].buf;

		Down_queue_ptr->cur_element++;
		if( Down_queue_ptr->cur_element < scat_ptr->num_elements )
		{
			/* not last packet in message */
			pack_ptr->packet_index = Down_queue_ptr->cur_element;
		}else if( Down_queue_ptr->cur_element == scat_ptr->num_elements ){
			down_link	*tmp_down;

			/* last packet in message */
			pack_ptr->packet_index = -scat_ptr->num_elements;

			tmp_down = Down_queue_ptr->first;
			Down_queue_ptr->first = Down_queue_ptr->first->next;
			Down_queue_ptr->cur_element = 0;
			Down_queue_ptr->num_mess--;
			dispose( tmp_down->mess );
			dispose( tmp_down );
			if( Down_queue_ptr->num_mess < WATER_MARK ) 
				Sess_unblock_users_level();
		}else{
			Alarm( EXIT, 
                          "Send_new_packets: error in packet index: %d %d\n",
			  Down_queue_ptr->cur_element,scat_ptr->num_elements );
		}

                Send_pack.elements[0].buf = (char *) pack_ptr;
                Send_pack.elements[1].len = pack_ptr->data_len;

#if 1
                ret = Net_queue_bcast( &Send_pack );
#else
                ret = Net_bcast( &Send_pack );
#endif
		if( ret > 0 )
		{
			num_sent++;
		}

                pack_entry = pack_ptr->seq & PACKET_MASK;
                if( Packets[pack_entry].exist ) 
                    Alarm( EXIT, 
                        "Send_new_packets: created packet %d already exist %d\n",
                        pack_ptr->seq, Packets[pack_entry].exist );

                /* insert new created packet */
                Packets[pack_entry].head       = pack_ptr;
                Packets[pack_entry].body       = (packet_body *)Send_pack.elements[1].buf;
                Packets[pack_entry].exist      = 1;
                Packets[pack_entry].proc_index = My_index;
                Alarm( PROTOCOL, 
			"Send_new_packets: packet %d sent and inserted \n",
			 pack_ptr->seq );
        }
	ret = Net_flush_bcast();
	if( ret > 0 )
	{
		num_sent++;
	}
	return ( num_sent );
}
Пример #15
0
void	Prot_handle_token(channel fd, int dummy, void *dummy_p)
{
	int		new_ptr;
	int		num_retrans, num_allowed, num_sent;
	int		flow_control;
	char		*new_rtr;
	ring_rtr	*ring_rtr_ptr;
	int32		rtr_proc_id;
	int16		rtr_seg_index;
	int32		val;
	int		retrans_allowed; /* how many of my retrans are allowed on token */
	int		i, ret;

	/*	int		r1,r2;*/

	ret = Net_recv_token( fd, &New_token );
	/* from another monitor component */
	if( ret == 0 ) return;

	/* delete random
	r1 = ((-My.id)%17)+3;
	r2 = get_rand() % (r1+3 );
	if ( r2 == 0 ) return; */

        Alarm( DEBUG, "Received Token\n");
	/* check if it is a regular token */
	if( Is_form( Token->type ) )
	{
                Alarm(PROTOCOL, "it is a Form Token.\n");
                Memb_handle_token( &New_token );
		return;
	}

	/* The Veto property for tokens - swallow this token */
	if( ! Memb_token_alive() ) {
                Alarm(PROTOCOL, "Prot_handle_token: Veto Property. Memb not alive.\n");
		return;
        }

	if( ret != sizeof(token_header) + Token->rtr_len )
	{
		Alarm( PRINT, 
		    "Prot_handle_token: recv token len is %d, should be %d\n",
		    ret,sizeof(token_header) + Token->rtr_len );
		return;
	}

	if( !Same_endian( Token->type ) ) 
		Flip_token_body( New_token.elements[1].buf, Token );

        /* Deal with wrapping seq values (2^32) by triggering a membership by dropping the token */
        if( (Memb_state() != EVS ) && (Token->seq > MAX_WRAP_SEQUENCE_VALUE ) )
        {
            Alarm( PRINT, "Prot_handle_token: Token Sequence number (%ld) approaching 2^31 so trigger membership to reset it.\n", Token->seq);

            return;
        }

	if( Conf_leader( Memb_active_ptr() ) == My.id )
	{
		if( Get_arq(Token->type) != Get_arq(Last_token->type) )
		{
		    Alarm( PROTOCOL, 
			"Prot_handle_token: leader swallowing token %d %d %d\n", 
			 Get_arq(Token->type),Get_retrans(Token->type),Get_arq(Last_token->type) );
		    /* received double token - swallow it */
		    return; 
		}
	}else{
		if( Get_arq(Token->type) == Get_arq(Last_token->type) )
		{
		    if( Get_retrans(Token->type) > Get_retrans(Last_token->type) )
		    {
			val = Get_retrans(Token->type);
			Last_token->type = Set_retrans(Last_token->type,val);
			/* asked to send token again (almost lost) */
			Alarm( PROTOCOL,
			    "Prot_handle_token: not leader, asked to retrans %d %d\n",
				Get_arq(Token->type), val );
			Prot_token_hurry();
		    }else{
			Alarm( PROTOCOL,
			    "Prot_handle_token: not leader, swallow same token %d %d\n",
	   			Get_arq(Token->type), Get_retrans(Token->type) );
		    }
		    return;

		} else if ( Get_arq(Token->type) != ( ( Get_arq( Last_token->type ) + 1 ) % 0x10 ) ) {
		  Alarm( PROTOCOL, 
			 "Prot_handle_token: not leader, swallowing very outdated token: ARQ(%d) RETRANS(%d) vs. Last ARQ(%d)\n",
			 Get_arq(Token->type), Get_retrans(Token->type), Get_arq(Last_token->type) );
		  return;

		} else {
                        if ( Get_retrans(Token->type) > 0 ) {
                                GlobalStatus.token_hurry++;
                        }
                }
	}
	if( Highest_seq < Token->seq ) Highest_seq = Token->seq;
		
	/* Handle retransmissions */
	num_retrans = Answer_retrans( &new_ptr, &rtr_proc_id, &rtr_seg_index );
	GlobalStatus.retrans += num_retrans;

	new_rtr = New_token.elements[1].buf;

	/* Handle new packets */
	flow_control = (int) Token->flow_control;
	num_allowed = FC_allowed( flow_control, num_retrans );
	num_sent    = Send_new_packets( num_allowed );
	GlobalStatus.packet_sent += num_sent;

	/* Flow control calculations */
	Token->flow_control = Token->flow_control
				- Last_num_retrans - Last_num_sent 
				+ num_retrans      + num_sent;
	Last_num_retrans = num_retrans;
	Last_num_sent	 = num_sent;

	/* Prepare my retransmission requests */

	for( i = My_aru+1; i <= Highest_seq; i++ )
	{
		if( ! Packets[i & PACKET_MASK].exist ) break;
		My_aru++;
	}
	GlobalStatus.my_aru = My_aru;

	if( My_aru < Highest_seq )
	{
	    /* Compute how many of my retransmission requests are possible to fit */
	    retrans_allowed = ( sizeof( token_body ) - new_ptr - sizeof( ring_rtr ) ) / sizeof( int32 );
	    if( retrans_allowed > 1 )
	    {
	    	ring_rtr_ptr = (ring_rtr *)&new_rtr[new_ptr];
	    	ring_rtr_ptr->memb_id 	= Memb_id();
	    	ring_rtr_ptr->proc_id	= rtr_proc_id;
	    	ring_rtr_ptr->seg_index	= rtr_seg_index;
	    	ring_rtr_ptr->num_seq	= 0;
	    	new_ptr += sizeof(ring_rtr);
	    	for( i=My_aru+1; i <= Highest_seq && retrans_allowed > 0; i++, retrans_allowed-- )
	    	{
			if( ! Packets[i & PACKET_MASK].exist ) 
			{
				memcpy( &new_rtr[new_ptr], &i, sizeof(int32) ); 
				new_ptr += sizeof(int32);
				ring_rtr_ptr->num_seq++;
			}
	    	}
	    }
	}

	if( Memb_state() == EVS )
	{
		if( My_aru == Highest_seq )
		{
			My_aru = Last_seq;
			Memb_commit();
		}
	}

	Token->rtr_len = new_ptr;
	New_token.elements[1].len = new_ptr;

	/* Calculating Token->aru and Set_aru */
	if( ( Token->aru == Set_aru    ) ||
            ( Token->aru_last_id == My.id ) ||
	    ( Token->aru == Token->seq ) )
	{
		Token->aru = My_aru;
                Token->aru_last_id = My.id;
		if( My_aru < Highest_seq ) Set_aru = My_aru;
		else Set_aru = -1;
	}else if( Token->aru > My_aru ) {
		Token->aru = My_aru;
                Token->aru_last_id = My.id;
		Set_aru    = My_aru;
	}else{
		Set_aru    = -1;
	}
	
	Token->proc_id = My.id;
	if( Memb_state() != EVS ) Token->seq = Highest_seq;

	if( Conf_leader( Memb_active_ptr() ) == My.id )
	{
	    	val = Get_arq( Token->type );
		val = (val + 1)% 0x10;
		Token->type = Set_arq(     Token->type, val );
		Token->type = Set_retrans( Token->type, 0   );
	}

	/* Send token */
	if( ! ( Conf_leader( Memb_active_ptr() ) == My.id &&
		To_hold_token() ) )
	{
		/* sending token */
		Net_send_token( &New_token );
/* ### Bug fix for SGIs */
#ifdef	ARCH_SGI_IRIX
		Net_send_token( &New_token );
#endif  /* ARCH_SGI_IRIX */

		if( Get_retrans( Token->type ) > 1 )
		{
			/* problems */ 
			Net_send_token( &New_token );
			Net_send_token( &New_token );
		}
	}

	Token_rounds++;

	if( Conf_leader( Memb_active_ptr() ) == My.id ) 
		E_queue( Prot_token_hurry, 0, NULL, Hurry_timeout );

	E_queue( Memb_token_loss, 0, NULL, Token_timeout );


	/* calculating Aru */
	if( Token->aru > Last_token->aru )
		Aru = Last_token->aru;
	else
		Aru = Token->aru;
	if( Highest_seq == Aru ) Token_counter++;
	else Token_counter = 0;

	dispose( Last_token );
	Last_token = Token;
	New_token.elements[0].buf = (char *) new(TOKEN_HEAD_OBJ);
	New_token.elements[1].len = sizeof(token_body);
	Token = (token_header *)New_token.elements[0].buf;

	/* Deliver & discard packets */

	Discard_packets();
	Deliver_agreed_packets();
	Deliver_reliable_packets( Highest_seq-num_sent+1, num_sent );

	if( Memb_state() == EVS && Token_rounds > MAX_EVS_ROUNDS ) 
	{
		Alarmp( SPLOG_ERROR, PRINT, "Prot_handle_token: BUG WORKAROUND: Too many rounds in EVS state; swallowing token; state:\n" );
		Alarmp( SPLOG_ERROR, PRINT, "\tAru:              %d\n",   Aru );
		Alarmp( SPLOG_ERROR, PRINT, "\tMy_aru:           %d\n",   My_aru );
		Alarmp( SPLOG_ERROR, PRINT, "\tHighest_seq:      %d\n",   Highest_seq );
		Alarmp( SPLOG_ERROR, PRINT, "\tHighest_fifo_seq: %d\n",   Highest_fifo_seq );
		Alarmp( SPLOG_ERROR, PRINT, "\tLast_discarded:   %d\n",   Last_discarded );
		Alarmp( SPLOG_ERROR, PRINT, "\tLast_delivered:   %d\n",   Last_delivered );
		Alarmp( SPLOG_ERROR, PRINT, "\tLast_seq:         %d\n",   Last_seq );
		Alarmp( SPLOG_ERROR, PRINT, "\tToken_rounds:     %d\n",   Token_rounds );
		Alarmp( SPLOG_ERROR, PRINT, "Last Token:\n" );
		Alarmp( SPLOG_ERROR, PRINT, "\ttype:             0x%x\n", Last_token->type );
		Alarmp( SPLOG_ERROR, PRINT, "\ttransmiter_id:    %d\n",   Last_token->transmiter_id );
		Alarmp( SPLOG_ERROR, PRINT, "\tseq:              %d\n",   Last_token->seq );
		Alarmp( SPLOG_ERROR, PRINT, "\tproc_id:          %d\n",   Last_token->proc_id );
		Alarmp( SPLOG_ERROR, PRINT, "\taru:              %d\n",   Last_token->aru );
		Alarmp( SPLOG_ERROR, PRINT, "\taru_last_id:      %d\n",   Last_token->aru_last_id );
		Alarmp( SPLOG_ERROR, PRINT, "\tflow_control:     %d\n",   Last_token->flow_control );
		Alarmp( SPLOG_ERROR, PRINT, "\trtr_len:          %d\n",   Last_token->rtr_len );
		Alarmp( SPLOG_ERROR, PRINT, "\tconf_hash:        %d\n",   Last_token->conf_hash );

		Memb_token_loss();
	}

	GlobalStatus.highest_seq = Highest_seq;
	GlobalStatus.aru = Aru;
	GlobalStatus.token_rounds = Token_rounds;
}
Пример #16
0
void keyboard(uchar key, int x, int y){
  if(key == 'q'){
    dispose();
    exit(0);
  }
}
Пример #17
0
void teardown(){
	dispose(queue);
}
Пример #18
0
Window::~Window()
{
    if (valid())
        dispose();
}
Пример #19
0
PacketManager::~PacketManager()
{
	if(!_disposing) dispose();
	if(_workerThread.joinable()) _workerThread.join();
}
Пример #20
0
MemoryHeapBase::~MemoryHeapBase()
{
    dispose();
}
Пример #21
0
ramActor::~ramActor()
{
	dispose();
}
Пример #22
0
Keyboard::~Keyboard() {
  START("");
  dispose();
  END("");
}
OcclusionEngine::~OcclusionEngine(void)
{
	dispose();
}
Пример #24
0
 Mesh::~Mesh()
 {
   dispose(); 
 }
Пример #25
0
 TextureManager::~TextureManager()
 {
     dispose();
 }
Пример #26
0
 ~Program()
 {
     dispose();
 }
Пример #27
0
ScriptRunner::~ScriptRunner()
{
#if !ENABLE(OILPAN)
    dispose();
#endif
}
Пример #28
0
Bitmap::~Bitmap()
{
	dispose();
}
Пример #29
0
 ~b_tree()
 {
     dispose();
 }
Пример #30
0
//-----------------------------------------------------------------------------
//! Destructor
//-----------------------------------------------------------------------------
GBI::~GBI()
{
    dispose();
}