Search  

---

C:/temp/src/j2k/nto/bak2/Track.cpp

Go to the documentation of this file.

#ifndef __J2K__Track_CPP__
#define __J2K__Track_CPP__

#include "Track.hpp"

Track::Track( int i = 0 ) 
: index( i ), reserved( 0L ), current( NULL )
{
  memset( &segment,        0, sizeof( segment       ) );
  memset( &length,         0, sizeof( length        ) );
  memset( &segment.left,  -1, sizeof( segment.left  ) );
  memset( &segment.right, -1, sizeof( segment.right ) );  

  segment.bit_name = i;
  
  occupied.set( 1 ); // Empty
  lock.set( 1 );     // Unlock
}

Track::Track( track_segment_t  seg )
: index( seg.bit_name ), reserved( 0L ), current( NULL )
{
  memset( &length,         0, sizeof( double ) * 10 );
  memcpy( &segment, &seg, sizeof( seg ) );

  occupied.set( 1 ); // Empty
  lock.set( 1 );     // Unlock
}

Track::Track( track_init_t init, track_segment_t  seg, double* l )
: index( seg.bit_name ), reserved( 0L ), current( NULL )
{
  memcpy( &length, l, sizeof( double ) * 10 );
  memcpy( &segment, &seg, sizeof( seg ) );
  
  occupied.set( 1 ); // Empty
  lock.set( 1 );     // Unlock

  // Verify boundaries
  assert( init.max_left  < 10 );
  assert( init.max_right < 10 );
  assert(  seg.max_left  < 10 );
  assert(  seg.max_right < 10 );

  assert( seg.bit_name  >= init.start_bit );
  assert( seg.bit_name  <= init.end_bit   );
  assert( seg.max_left  <= init.max_left  );
  assert( seg.max_right <= init.max_right );

  assert( seg.left[  seg.max_left  ] == -1 );
  assert( seg.right[ seg.max_right ] == -1 );
}

Track::~Track()
{
  // Unlock, clean up
}

// v = 1 means that someone can take the lock
BOOL Track::isEmpty() 
{
  lock.P();
    register int b = ( current == NULL );
    register int v = occupied.get();
  lock.V();

  return ( v >= 0  &&  b );
}

// v = 0 means that someone must wait to get the lock
BOOL Track::isFull() 
{
  lock.P();
    register int b = ( current != NULL );
    register int v = occupied.get();
  lock.V();

  return ( v >= 0  &&  b );
}

long Track::isReserved() 
{
  lock.P();
    register int b = ( current == NULL );
    register int r = reserved;
  lock.V();

  if ( b ) return -1;
  return r;
}

Train* Track::getTrain() 
{
  return current;
}

long Track::setTrain()
{
  return setTrain( NULL, 0 );
}

long Track::setTrain( Train* t, long r = 1 )
{
  lock.P();
    if ( current != NULL )
    {
      if ( current->isStronger( t, r ) )
      {
        lock.V();
        return -1;               // Wait buddy, I'm more important !
      } 
      else 
      {
        current->notify( t, r ); // Damn, I lost the track permission !
      }
    } else {

      occupied.P();
    }

    current  = t;
    reserved = r;

  lock.V();
  return r;
}

long Track::getLeft( size_t index  ) 
{
  register long rtn = -1;

  lock.P();
    if ( (long)index <= segment.max_left ) {
      rtn = segment.left[ index ];
    }
  lock.V();

  return rtn;
}

long Track::getRight( size_t index ) 
{
  register long rtn = -1;

  lock.P();
    if ( (long)index <= segment.max_right ) {
      rtn = segment.right[ index ];
    }
  lock.V();

  return rtn;
}

long Track::getLeftEmpty( Track** tracks ) 
{
  register long i = 0;
  register long t = 0;
  register BOOL e = FALSE;

  lock.P();

    for( ; i < segment.max_left; i++ )
    {
      t = segment.left[ i ];
      e = tracks[ t ]->isEmpty();
  
      if ( e ) {
        lock.V();
        return t;
      }
    }
 
  lock.V();

  return -1;
}

long Track::getRightEmpty( Track** tracks ) 
{
  register long i = 0;
  register long t = 0;
  register BOOL e = FALSE;

  lock.P();

    for( ; i < segment.max_right; i++ )
    {
      t = segment.right[ i ];
      e = tracks[ t ]->isEmpty(); 
 
      if ( e ) {
        lock.V();
        return t;
      }
    }

  lock.V();

  return -1;
}

long Track::getMaxLeft() 
{
  lock.P();
    register long l = segment.max_left;
  lock.V();

  return l;
}

long Track::getMaxRight() 
{
  lock.P();
    register long l = segment.max_right;
  lock.V();

  return l;
}

double Track::getLength( size_t index = 0 ) 
{
  lock.P();
    register double d = length[ index ];
  lock.V();

  return d;
}

track_type_t  Track::getType( size_t index = 0 ) 
{
  lock.P();
    register track_type_t i = segment.type[ index ];
  lock.V();

  return i;
}

long Track::getLengthName( size_t index = 0 ) 
{
  lock.P();
    register long l = segment.length_name[ index ];
  lock.V();

  return l;
}

#endif

---