int
main( int argc, char *argv[] )
{
DirectResult ret;
pid_t child_pid;
TestMessage message = {0};
FusionReactor *reactor;
Reaction reaction;
FusionCall call;
DirectFBInit( &argc, &argv );
ret = fusion_enter( -1, 0, FER_MASTER, &m_world );
if (ret) {
D_DERROR( ret, "fusion_enter() failed" );
return ret;
}
MSG( "Entered world %d as master (FusionID %lu, pid %d)\n",
fusion_world_index( m_world ), fusion_id( m_world ), getpid() );
reactor = fusion_reactor_new( sizeof(TestMessage), "Test", m_world );
if (!reactor) {
D_ERROR( "fusion_reactor_new() failed\n" );
return -1;
}
MSG( "Attaching to reactor...\n" );
ret = fusion_reactor_attach( reactor, reaction_callback, NULL, &reaction );
if (ret) {
D_DERROR( ret, "fusion_reactor_attach() failed" );
return ret;
}
MSG( ".........FORKING NOW.........\n" );
fusion_world_set_fork_action( m_world, FFA_FORK );
child_pid = fork();
fusion_world_set_fork_action( m_world, FFA_CLOSE );
switch (child_pid) {
case -1:
D_PERROR( "fork() failed" );
break;
case 0:
setsid();
MSG( "...arrived after fork() in child (pid %d)..\n", getpid() );
MSG( "..child (FusionID %lu).\n", fusion_id( m_world ) );
usleep( 400000 );
break;
default:
usleep( 100000 );
MSG( "...returned from fork() in parent, child pid %d.\n", child_pid );
MSG( "Initializing dispatch callback...\n" );
ret = fusion_call_init( &call, dispatch_callback, NULL, m_world );
if (ret) {
D_DERROR( ret, "fusion_call_init() failed" );
return ret;
}
MSG( "Setting dispatch callback...\n" );
ret = fusion_reactor_set_dispatch_callback( reactor, &call, NULL );
if (ret) {
D_DERROR( ret, "fusion_reactor_set_dispatch_callback() failed" );
return ret;
}
MSG( "Sending message via reactor...\n" );
fusion_reactor_dispatch( reactor, &message, true, NULL );
usleep( 100000 );
MSG( "Destroying reactor...\n" );
fusion_reactor_destroy( reactor );
MSG( "...destroyed reactor!\n" );
usleep( 400000 );
MSG( "Freeing reactor...\n" );
fusion_reactor_free( reactor );
MSG( "...freed reactor!\n" );
break;
}
MSG( "Exiting from world %d (FusionID %lu, pid %d)...\n",
fusion_world_index( m_world ), fusion_id( m_world ), getpid() );
fusion_exit( m_world, false );
return 0;
}
int
main( int argc, char *argv[] )
{
DirectResult ret;
FusionWorld *world;
FusionCall call = {0};
FusionSHMPoolShared *pool;
void *buffer;
int i, max_busy = 0, active = 1;
long long t1 = 0, t2;
long long start = 0;
long long bytes = 0;
long long last_bytes = 0;
unsigned long blocks = 0;
unsigned long last_blocks = 0;
unsigned long last_busy = 0;
u32 checksum = 0;
bool produce = true;
int delay = 66000;
if (parse_cmdline( argc, argv ))
return -1;
if (bit_rate) {
int blocks_per_sec = (bit_rate * 1024 / 8) / block_size;
if (blocks_per_sec < 100)
delay = 900000 / blocks_per_sec - 2000;
else
delay = 300000 * 100 / blocks_per_sec;
num_blocks = bit_rate * 1024 / 8 / block_size * delay / 900000;
if (num_blocks > MAX_NUM_BLOCKS)
num_blocks = MAX_NUM_BLOCKS;
if (!num_blocks) {
num_blocks = 1;
delay = 970 * block_size / (bit_rate * 1024 / 8) * 1000 - 2000;
}
}
sync();
if (run_busy) {
pthread_create( &busy_thread, NULL, busy_loop, NULL );
printf( "Calibrating...\n" );
pthread_mutex_lock( &busy_lock );
for (i=0; i<7; i++) {
int busy_rate;
busy_count = 0;
t1 = get_millis();
pthread_mutex_unlock( &busy_lock );
usleep( 300000 );
pthread_mutex_lock( &busy_lock );
t2 = get_millis();
busy_rate = busy_count * 1000 / (t2 - t1);
if (busy_rate > max_busy)
max_busy = busy_rate;
}
printf( "Calibrating done. (%d busy counts/sec)\n", max_busy );
}
ret = fusion_enter( -1, 23, FER_MASTER, &world );
if (ret)
return ret;
ret = fusion_call_init( &call, call_handler, NULL, world );
if (ret)
return ret;
ret = fusion_shm_pool_create( world, "Stream Buffer", block_size + 8192, false, &pool );
if (ret)
return ret;
ret = fusion_shm_pool_allocate( pool, block_size, false, true, &buffer );
if (ret)
return ret;
/*
* Do the fork() magic!
*/
if (do_fork) {
fusion_world_set_fork_action( world, FFA_FORK );
switch (fork()) {
case -1:
D_PERROR( "fork() failed!\n" );
return -1;
case 0:
/* child continues as the producer */
run_busy = false;
break;
default:
/* parent is the consumer (callback in Fusion Dispatch thread) */
produce = false;
usleep( 50000 );
}
fusion_world_set_fork_action( world, FFA_CLOSE );
}
start = t1 = get_millis();
if (run_busy) {
busy_count = 0;
pthread_mutex_unlock( &busy_lock );
}
#ifdef LINUX_2_4
delay -= 10000;
#endif
do {
if (bit_rate || !produce) {
if (delay > 10)
usleep( delay );
}
if (produce) {
for (i=0; i<num_blocks; i++) {
int n;
u32 retsum;
u32 *values = buffer;
for (n=0; n<block_size/4; n++) {
values[n] = n;
checksum += n;
}
bytes += block_size;
fusion_call_execute( &call, do_thread ? FCEF_NODIRECT : FCEF_NONE,
0, buffer, (int*) &retsum );
if (retsum != checksum)
D_ERROR( "Checksum returned by consumer (0x%08x) does not match 0x%08x!\n", retsum, checksum );
}
blocks += num_blocks;
}
t2 = get_millis();
if (t2 - t1 > 2000) {
if (produce) {
long long kbits = 0, avgkbits, total_time, diff_time, diff_bytes;
printf( "\n\n\n" );
total_time = t2 - start;
diff_time = t2 - t1;
diff_bytes = bytes - last_bytes;
avgkbits = (long long)bytes * 8LL * 1000LL / (long long)total_time / 1024LL;
if (diff_time)
kbits = (long long)diff_bytes * 8LL * 1000LL / (long long)diff_time / 1024LL;
printf( "Total Time: %7lld ms\n", total_time );
printf( "Stream Size: %7lld kb\n", bytes / 1024 );
printf( "Stream Rate: %7lld kb/sec -> %lld.%03lld MBit (avg. %lld.%03lld MBit)\n",
kbits / 8,
(kbits * 1000 / 1024) / 1000, (kbits * 1000 / 1024) % 1000,
(avgkbits * 1000 / 1024) / 1000, (avgkbits * 1000 / 1024) % 1000 );
printf( "\n" );
if (last_bytes && bit_rate) {
long long diff_bytes = (bytes - last_bytes) * 1000 / (t2 - t1);
long long need_bytes = bit_rate * 1024 / 8;
if (diff_bytes) {
int new_blocks = (num_blocks * need_bytes + diff_bytes/2) / diff_bytes;
num_blocks = (new_blocks + num_blocks + 1) / 2;
if (num_blocks > MAX_NUM_BLOCKS)
num_blocks = MAX_NUM_BLOCKS;
}
}
read_stat();
if (ftotal != ctotal && dtotal) {
int load, aload;
load = 1000 - didle * 1000 / dtotal;
aload = 1000 - (cidle - fidle) * 1000 / (ctotal - ftotal);
printf( "Overall Stats\n" );
printf( " Total Time: %7lld ms\n", t2 - start );
printf( " Block Size: %7ld\n", block_size );
printf( " Blocks/cycle: %7ld\n", num_blocks );
printf( " Blocks/second: %7lld\n", (blocks - last_blocks) * 1000 / diff_time );
printf( " Delay: %7d\n", delay );
printf( " CPU Load: %5d.%d %% (avg. %d.%d %%)\n",
load / 10, load % 10, aload / 10, aload % 10 );
}
last_bytes = bytes;
last_blocks = blocks;
}
if (run_busy) {
pthread_mutex_lock( &busy_lock );
if (last_busy) {
int busy_diff;
int busy_rate, busy_load;
int abusy_rate, abusy_load;
busy_diff = busy_count - last_busy;
busy_rate = max_busy - (busy_diff * 1000 / (t2 - t1));
busy_load = busy_rate * 1000 / max_busy;
abusy_rate = max_busy - (busy_count * 1000 / (t2 - start));
abusy_load = abusy_rate * 1000 / max_busy;
printf( " Real CPU Load: %5d.%d %% (avg. %d.%d %%)\n",
busy_load / 10, busy_load % 10,
abusy_load / 10, abusy_load % 10 );
}
last_busy = busy_count;
pthread_mutex_unlock( &busy_lock );
}
t1 = t2;
}
} while (active > 0);
if (run_busy) {
busy_alive = 0;
pthread_join( busy_thread, NULL );
}
return -1;
}
int
main( int argc, char *argv[] )
{
DirectResult ret;
pid_t child_pid;
TestMessage message = {0};
DirectFBInit( &argc, &argv );
ret = fusion_enter( -1, 0, FER_MASTER, &m_world );
if (ret) {
D_DERROR( ret, "fusion_enter() failed" );
return ret;
}
MSG( "Entered world %d as master (FusionID %lu, pid %d)\n",
fusion_world_index( m_world ), fusion_id( m_world ), getpid() );
ret = fusion_ref_init( &m_ref, "Test", m_world );
if (ret) {
D_DERROR( ret, "fusion_ref_init() failed" );
return -1;
}
MSG( "Adding local reference...\n" );
fusion_ref_up( &m_ref, false );
m_reactor = fusion_reactor_new( sizeof(TestMessage), "Test", m_world );
if (!m_reactor) {
D_ERROR( "fusion_reactor_new() failed\n" );
return -1;
}
MSG( "Attaching to reactor...\n" );
ret = fusion_reactor_attach( m_reactor, reaction_callback, NULL, &m_reaction );
if (ret) {
D_DERROR( ret, "fusion_reactor_attach() failed" );
return ret;
}
MSG( ".........FORKING NOW.........\n" );
fusion_world_set_fork_action( m_world, FFA_FORK );
child_pid = fork();
fusion_world_set_fork_action( m_world, FFA_CLOSE );
switch (child_pid) {
case -1:
D_PERROR( "fork() failed" );
break;
case 0:
setsid();
MSG( "...arrived after fork() in child (pid %d)..\n", getpid() );
MSG( "..child (FusionID %lu).\n", fusion_id( m_world ) );
break;
default:
usleep( 200000 );
MSG( "...returned from fork() in parent, child pid %d.\n", child_pid );
break;
}
MSG( "Sending message via reactor...\n" );
fusion_reactor_dispatch( m_reactor, &message, true, NULL );
usleep( 200000 );
MSG( "Removing local reference...\n" );
fusion_ref_down( &m_ref, false );
usleep( 200000 );
MSG( "Exiting from world %d (FusionID %lu, pid %d)...\n",
fusion_world_index( m_world ), fusion_id( m_world ), getpid() );
fusion_exit( m_world, false );
return 0;
}
