bool BCSPImplementation::connect(uint32 timeout)
{
    //wait for timeout or until we have link-establishment
    int32 timeoutTime = ms_clock() + timeout ;
    do
    {
        if (BCSPLinkEstablished(mStack))
            return true ;
        sleep(10) ;
    } while ( (int32)(timeoutTime-ms_clock()) > 0) ; 
    return false ;
}
void BCSPImplementation::wait(uint32 wakeupTime)
{
    //this function just puts the stack thread into idle until some
    //event (or timeout) wakes us up.
    int32 timeout = wakeupTime - ms_clock();
    if (timeout <= 0)
        return;

    // There appears to be a bug in the WriteFile
    // implementation under Win98.  Occasionally, the WriteFile never
    // sets the completion event.  Close down and then reopen the com port 
    // if the writefile hasn't completed after a certain period.
    if (mXMITBusy && (ms_clock() - mLastXmitTime > WRITEFILE_PERIOD)) 
    {
        BTRACE3(WINERR,"Cancelling IO at time %d (%d ms from %d)\n", ms_clock(), WRITEFILE_PERIOD, mLastXmitTime);
        mLastXmitTime = ms_clock() ;
        mXMITBusy = false;
        mRCVBusy = false;
        mFile->reopen();
        return;
    }
    //on with the real code...

    switch ( mFile->wait ( timeout , &mRCVBytesAvailable ) )
    {
    case UARTAbstraction::UART_XMITDONE : //This is the transmit-finished - all we need to do is reset the event
        mXMITBusy = false ; 
        BTRACE0(USER0,"TX DONE\n") ;
        break ; //allow xmit to go ahead 
    case UARTAbstraction::UART_RCVDONE: //This is a receive from the uart 
        mRCVBusy = false ;
        BTRACE0(USER0,"RX DONE\n") ;
        break ;
    case UARTAbstraction::CLIENT_TXREQ:
        BTRACE0(USER0,"TX REQUEST\n") ;
        break ;//write req - no action necessary
    case UARTAbstraction::CLIENT_DIEREQ: //the user has requested that we shutdown
        BTRACE0(USER0,"DIE REQUEST\n") ;
        break ;
    case UARTAbstraction::timedOut:
        BTRACE0(USER0,"WAIT TIMEOUT\n") ;
        break;
    case UARTAbstraction::UART_ERROR:
        onLinkFailUart();
        BTRACE0(USER0,"UART ERROR\n") ;
        break;
    default :
        BTRACE0(USER0,"BAD WAIT VALUE\n") ;
        break ;//error!
    }
}
예제 #3
0
파일: memory.c 프로젝트: muennich/mupdf
void fz_lock_debug_lock(fz_context *ctx, int lock)
{
	int i, idx;

	if (ctx->locks.lock != fz_lock_default)
		return;

	idx = find_context(ctx);
	if (idx < 0)
		return;

	if (fz_locks_debug[idx][lock] != 0)
	{
		fprintf(stderr, "Attempt to take lock %d when held already!\n", lock);
	}
	for (i = lock-1; i >= 0; i--)
	{
		if (fz_locks_debug[idx][i] != 0)
		{
			fprintf(stderr, "Lock ordering violation: Attempt to take lock %d when %d held already!\n", lock, i);
		}
	}
	fz_locks_debug[idx][lock] = 1;
#ifdef FITZ_DEBUG_LOCKING_TIMES
	fz_lock_taken[idx][lock] = ms_clock();
#endif
}
예제 #4
0
파일: memory.c 프로젝트: muennich/mupdf
static void dump_lock_times(void)
{
	int i, j;
	int prog_time = ms_clock() - fz_lock_program_start;

	for (j = 0; j < FZ_LOCK_MAX; j++)
	{
		int total = 0;
		for (i = 0; i < FZ_LOCK_DEBUG_CONTEXT_MAX; i++)
		{
			total += fz_lock_time[i][j];
		}
		printf("Lock %d held for %g seconds (%g%%)\n", j, total / 1000.0f, 100.0f*total/prog_time);
	}
	printf("Total program time %g seconds\n", prog_time / 1000.0f);
}
void BCSPImplementation::runStack()
{
    //here's where we actually run round in a loop calling the scheduler...
    while(!mStackMustDie)
    {
        uint32 timeNow = ms_clock() ;
        uint32 wakeupTime = scheduler(mStack,timeNow) ;
        //now see if we can do anything with the uart...
        //try sending ...
        if(!mXMITBusy) 
        {
            //copy stuff out of stack output buffer 
            mXMITBytesAvailable = numBytesInTransmitBuffer(mStack) ;
            if (mXMITBytesAvailable)
            {
                readFromTransmitBuffer(mStack,mXMITBuffer, mXMITBytesAvailable) ;
                if (mXMITBytesAvailable) 
                {
                    BTRACE0(IO,"-->") ;
                    for (unsigned int c = 0 ; c < mXMITBytesAvailable ; c++)
                        PLAINBTRACE1(IO," %02x",mXMITBuffer[c]) ;
                    PLAINBTRACE0(IO,"\n") ;
                }
            }
        }

        //now startup I/O  - non-zero indicates that the read or write has returned immediately
        if (!startIO() && isStackIdle(mStack))
                wait(wakeupTime) ;

        //now try loading the stack receive buffer
        if (mRCVBytesAvailable &&(mRCVBytesAvailable <= numFreeSlotsInReceiveBuffer(mStack)))
        {
            if (mRCVBytesAvailable) 
            {
                BTRACE0(IO,"<--") ;
                for (unsigned int c = 0 ; c < mRCVBytesAvailable ; c++) PLAINBTRACE1(IO," %02x",mRCVBuffer[c]) ;
                PLAINBTRACE0(IO,"\n") ;
            }
            writeToReceiveBuffer(mStack,mRCVBuffer,(uint8) mRCVBytesAvailable) ;
            mRCVBytesAvailable = 0 ;
        }
    }
    //we'll return if we get the stackmustdie signal
} 
uint8 BCSPImplementation::startIO()
{
    uint8 retval = 0 ;
    int  err ;
    if ((!mXMITBusy) && (mXMITBytesAvailable))
    {
        mXMITBusy = true ;
        mLastXmitTime = ms_clock() ;
        if ( mFile->write(mXMITBuffer,mXMITBytesAvailable,&mXMITbytesWritten) )
        {
            //function succeeded immediately
            mXMITBusy = false ;
            retval =1 ;
        }
        else if ( ( err = mFile->LastError() ) )
        {
            mXMITBusy = false ;
            BTRACE1(WINERR,"WriteFile error %d\n",err) ;
            BTRACE1(WINERR,"bytesavail = %d",mXMITBytesAvailable);
            BTRACE1(WINERR,"byteswritten = %d",mXMITbytesWritten);
        }
    }

    if ((!mRCVBusy)  && (!mRCVBytesAvailable))
    {        
        //Now try to read some chars from the uart.
        uint16 bytesToGet = numFreeSlotsInReceiveBuffer(mStack) ;
        mRCVBusy = true ;
        if ( mFile->read( mRCVBuffer , bytesToGet , &mRCVBytesAvailable ) )
        {
            mRCVBusy = false ;
            retval =1 ;
        }
        else if ( (err = mFile->LastError()) )
        {
            mRCVBusy = false ;
            BTRACE1(WINERR,"ReadFile error %d\n",err) ;
        }
    }

    return retval ; //indicate that we need to wait for some io to complete or not
}
예제 #7
0
파일: memory.c 프로젝트: muennich/mupdf
void fz_lock_debug_unlock(fz_context *ctx, int lock)
{
	int idx;

	if (ctx->locks.lock != fz_lock_default)
		return;

	idx = find_context(ctx);
	if (idx < 0)
		return;

	if (fz_locks_debug[idx][lock] == 0)
	{
		fprintf(stderr, "Attempt to release lock %d when not held!\n", lock);
	}
	fz_locks_debug[idx][lock] = 0;
#ifdef FITZ_DEBUG_LOCKING_TIMES
	fz_lock_time[idx][lock] += ms_clock() - fz_lock_taken[idx][lock];
#endif
}
예제 #8
0
파일: memory.c 프로젝트: muennich/mupdf
static int find_context(fz_context *ctx)
{
	int i;

	for (i = 0; i < FZ_LOCK_DEBUG_CONTEXT_MAX; i++)
	{
		if (fz_lock_debug_contexts[i] == ctx)
			return i;
		if (fz_lock_debug_contexts[i] == NULL)
		{
			int gottit = 0;
			/* We've not locked on this context before, so use
			 * this one for this new context. We might have other
			 * threads trying here too though so, so claim it
			 * atomically. No one has locked on this context
			 * before, so we are safe to take the ALLOC lock. */
			ctx->locks.lock(ctx->locks.user, FZ_LOCK_ALLOC);
			/* If it's still free, then claim it as ours,
			 * otherwise we'll keep hunting. */
			if (fz_lock_debug_contexts[i] == NULL)
			{
				gottit = 1;
				fz_lock_debug_contexts[i] = ctx;
#ifdef FITZ_DEBUG_LOCKING_TIMES
				if (fz_debug_locking_inited == 0)
				{
					fz_debug_locking_inited = 1;
					fz_lock_program_start = ms_clock();
					atexit(dump_lock_times);
				}
#endif
			}
			ctx->locks.unlock(ctx->locks.user, FZ_LOCK_ALLOC);
			if (gottit)
				return i;
		}
	}
	return -1;
}