exile/v1/src/chuck_vm.cpp

   1 /*----------------------------------------------------------------------------
   2     ChucK Concurrent, On-the-fly Audio Programming Language
   3       Compiler and Virtual Machine
   4
   5     Copyright (c) 2004 Ge Wang and Perry R. Cook.  All rights reserved.
   6       http://chuck.cs.princeton.edu/
   7       http://soundlab.cs.princeton.edu/
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17     GNU General Public License for more details.
  18
  19     You should have received a copy of the GNU General Public License
  20     along with this program; if not, write to the Free Software
  21     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  22     U.S.A.
  23 -----------------------------------------------------------------------------*/
  24
  25 //-----------------------------------------------------------------------------
  26 // file: chuck_vm.cpp
  27 // desc: ...
  28 //
  29 // authors: Ge Wang (gewang@cs.princeton.edu)
  30 //          Perry R. Cook (prc@cs.princeton.edu)
  31 // date: Autumn 2002
  32 //-----------------------------------------------------------------------------
  33 #include "chuck_vm.h"
  34 #include "chuck_instr.h"
  35 #include "chuck_bbq.h"
  36 #include "chuck_errmsg.h"
  37
  38 #include <vector>
  39 using namespace std;
  40
  41 #if defined(__WINDOWS_DS__) && !defined(__WINDOWS_PTHREAD__)
  42   #include <windows.h>
  43 #else
  44   #include <unistd.h>
  45   #include <pthread.h>
  46 #endif
  47
  48
  49
  50 //-----------------------------------------------------------------------------
  51 // name: class Chuck_VM_Frame
  52 // desc: func frame
  53 //-----------------------------------------------------------------------------
  54 class Chuck_VM_Frame
  55 {
  56 public:
  57     t_CKUINT size;
  58
  59 public:
  60     Chuck_VM_Frame() { size = 0; }
  61     ~Chuck_VM_Frame() { }
  62 };
  63
  64
  65
  66
  67 //-----------------------------------------------------------------------------
  68 // name: class Chuck_VM_Func
  69 // desc: vm function
  70 //-----------------------------------------------------------------------------
  71 class Chuck_VM_Func
  72 {
  73 public:
  74     Chuck_VM_Code * code;
  75     Chuck_VM_Frame * frame;
  76     t_CKUINT index;
  77
  78 public:
  79     Chuck_VM_Func() { code = NULL; frame = NULL; index = 0; }
  80     ~Chuck_VM_Func() { }
  81 };
  82
  83
  84
  85
  86 //-----------------------------------------------------------------------------
  87 // name: class Chuck_VM_FTable
  88 // desc: function table
  89 //-----------------------------------------------------------------------------
  90 class Chuck_VM_FTable
  91 {
  92 public:
  93     Chuck_VM_FTable();
  94     ~Chuck_VM_FTable();
  95
  96 public:
  97     Chuck_VM_Func * get_func( t_CKUINT index );
  98     t_CKUINT append( Chuck_VM_Func * f );
  99     t_CKBOOL remove( t_CKUINT index );
 100
 101 public:
 102     vector<Chuck_VM_Func *> func_table;
 103 };
 104
 105
 106
 107
 108 //-----------------------------------------------------------------------------
 109 // name: Chuck_VM()
 110 // desc: ...
 111 //-----------------------------------------------------------------------------
 112 Chuck_VM::Chuck_VM()
 113 {
 114     m_shreds = NULL;
 115     m_num_shreds = 0;
 116     m_shreduler = NULL;
 117     m_msg_buffer = NULL;
 118     m_shred_id = 0;
 119     m_halt = TRUE;
 120     m_env = NULL;
 121     m_audio = FALSE;
 122
 123     m_init = FALSE;
 124 }
 125
 126
 127
 128
 129 //-----------------------------------------------------------------------------
 130 // name: ~Chuck_VM()
 131 // desc: ...
 132 //-----------------------------------------------------------------------------
 133 Chuck_VM::~Chuck_VM()
 134 {
 135     if( m_init ) shutdown();
 136 }
 137
 138
 139 // dac tick
 140 UGEN_TICK __dac_tick( t_CKTIME now, void * data, SAMPLE in, SAMPLE * out )
 141 { *out = in; return TRUE; }
 142 UGEN_TICK __bunghole_tick( t_CKTIME now, void * data, SAMPLE in, SAMPLE * out )
 143 { *out = 0.0f; return TRUE; }
 144
 145
 146 // static
 147 #ifdef __MACOSX_CORE__
 148 t_CKINT Chuck_VM::our_priority = 95;
 149 #else
 150 t_CKINT Chuck_VM::our_priority = 0x7fffffff;
 151 #endif
 152
 153
 154 #ifndef __WINDOWS_DS__
 155 //-----------------------------------------------------------------------------
 156 // name: set_priority()
 157 // desc: ...
 158 //-----------------------------------------------------------------------------
 159 t_CKBOOL Chuck_VM::set_priority( t_CKINT priority, Chuck_VM * vm )
 160 {
 161     struct sched_param param;
 162     pthread_t tid = pthread_self();
 163     int policy;
 164     // get for thread
 165     if( pthread_getschedparam( tid, &policy, &param) )
 166     {
 167         if( vm )
 168             vm->m_last_error = "could not get current scheduling parameters";
 169         return FALSE;
 170     }
 171
 172     // priority
 173     param.sched_priority = priority;
 174     // policy
 175     policy = SCHED_RR;
 176     // set for thread
 177     if( pthread_setschedparam( tid, policy, &param ) )
 178     {
 179         if( vm )
 180             vm->m_last_error = "could not set new scheduling parameters";
 181         return FALSE;
 182     }
 183
 184     return TRUE;
 185 }
 186 #else
 187 //-----------------------------------------------------------------------------
 188 // name: set_priority()
 189 // desc: ...
 190 //-----------------------------------------------------------------------------
 191 t_CKBOOL Chuck_VM::set_priority( t_CKINT priority, Chuck_VM * vm )
 192 {
 193     // if priority is 0, then do nothing
 194     if( !priority )
 195         return TRUE;
 196
 197     // set the priority class of the process
 198     // if( !SetPriorityClass( GetCurrentProcess(), HIGH_PRIORITY_CLASS ) )
 199     //     return FALSE;
 200
 201     // set the priority the thread
 202     if( !SetThreadPriority( GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL ) )
 203     {
 204         if( vm )
 205             vm->m_last_error = "could not set new scheduling parameters";
 206         return FALSE;
 207     }
 208
 209     return TRUE;
 210 }
 211 #endif
 212
 213
 214
 215
 216 //-----------------------------------------------------------------------------
 217 // name: initialize()
 218 // desc: ...
 219 //-----------------------------------------------------------------------------
 220 t_CKBOOL Chuck_VM::initialize( t_CKBOOL enable_audio, t_CKBOOL halt, t_CKUINT srate,
 221                                t_CKUINT buffer_size, t_CKUINT num_buffers,
 222                                t_CKUINT dac, t_CKUINT adc, t_CKINT priority )
 223 {
 224     if( m_init )
 225     {
 226         m_last_error = "VM already initialized!";
 227         return FALSE;
 228     }
 229
 230 //#ifndef __WINDOWS_DS__
 231     // boost thread priority
 232     if( priority != 0x7fffffff && !set_priority( priority, this ) )
 233         return FALSE;
 234 //#endif
 235
 236     // allocate bbq
 237     m_bbq = new BBQ;
 238     m_halt = halt;
 239     m_audio = enable_audio;
 240
 241     // allocate shreduler
 242     m_shreduler = new Chuck_VM_Shreduler;
 243     m_shreduler->bbq = m_audio ? m_bbq : NULL;
 244
 245     // allocate msg buffer
 246     m_msg_buffer = new CBuffer;
 247     m_msg_buffer->initialize( 1024, sizeof(Chuck_Msg *) );
 248     m_reply_buffer = new CBuffer;
 249     m_reply_buffer->initialize( 1024, sizeof(Chuck_Msg *) );
 250
 251     // allocate dac and adc
 252     m_num_dac_channels = 2;
 253     m_dac = new Chuck_UGen[2];
 254     m_dac[0].tick = __dac_tick;
 255     m_dac[1].tick = __dac_tick;
 256     m_num_adc_channels = 2;
 257     m_adc = new Chuck_UGen[2];
 258     m_bunghole = new Chuck_UGen;
 259     m_dac[0].add_ref(); m_dac[1].add_ref();
 260     m_adc[0].add_ref(); m_adc[1].add_ref();
 261     m_bunghole->add_ref();
 262     m_shreduler->m_dac = m_dac;
 263     m_shreduler->m_adc = m_adc;
 264     m_shreduler->m_bunghole = m_bunghole;
 265     m_shreduler->m_num_dac_channels = m_num_dac_channels;
 266     m_shreduler->m_num_adc_channels = m_num_adc_channels;
 267
 268     if( m_audio )
 269     {
 270         // init bbq
 271         if( !m_bbq->initialize( 2, srate, 16, buffer_size, num_buffers, dac, adc ) )
 272         {
 273             m_last_error = "cannot initialize audio device (try using --silent/-s)";
 274             return FALSE;
 275         }
 276     }
 277     else
 278     {
 279         // at least set the sample rate and buffer size
 280         m_bbq->set_srate( srate );
 281         m_bbq->set_bufsize( buffer_size );
 282     }
 283
 284     // m_bbq->midi_out()->open( 0 );
 285     // m_bbq->midi_in()->open( 0 );
 286
 287     return m_init = TRUE;
 288 }
 289
 290
 291
 292
 293 //-----------------------------------------------------------------------------
 294 // name: shutdown()
 295 // desc: ...
 296 //-----------------------------------------------------------------------------
 297 t_CKBOOL Chuck_VM::shutdown()
 298 {
 299     // make sure we are in the initialized state
 300     if( !m_init ) return FALSE;
 301
 302     // stop
 303     this->stop();
 304     usleep( 50000 );
 305
 306     // dll
 307     this->dll_clear();
 308
 309     // free the shreduler
 310     SAFE_DELETE( m_shreduler );
 311
 312     // terminate shreds
 313     Chuck_VM_Shred * curr = m_shreds, * prev = NULL;
 314     while( curr )
 315     {
 316         prev = curr;
 317         curr = curr->next;
 318         // delete prev;
 319     }
 320     m_shreds = NULL;
 321     m_num_shreds = 0;
 322
 323     // shutdown audio
 324     if( m_audio )
 325     {
 326         m_bbq->digi_out()->cleanup();
 327         m_bbq->digi_in()->cleanup();
 328         m_bbq->shutdown();
 329         SAFE_DELETE( m_bbq );
 330         m_audio = FALSE;
 331     }
 332
 333     m_init = FALSE;
 334
 335     return TRUE;
 336 }
 337
 338
 339
 340
 341 //-----------------------------------------------------------------------------
 342 // name: run()
 343 // desc: ...
 344 //-----------------------------------------------------------------------------
 345 t_CKBOOL Chuck_VM::run( )
 346 {
 347     m_running = TRUE;
 348     Chuck_VM_Shred * shred = NULL;
 349     Chuck_Msg * msg = NULL;
 350
 351     // audio
 352     if( m_audio )
 353     {
 354         if( !m_bbq->digi_out()->initialize( ) )
 355         {
 356             m_last_error = "cannot open audio output (option: use --silent/-s)";
 357             return FALSE;
 358         }
 359
 360         m_bbq->digi_in()->initialize( );
 361         m_bbq->digi_out()->start();
 362         m_bbq->digi_in()->start();
 363     }
 364
 365     while( m_running )
 366     {
 367         // get the shreds queued for 'now'
 368         while( shred = m_shreduler->get() )
 369         {
 370             // set the current time of the shred
 371             shred->now = shred->wake_time;
 372
 373             // run the shred
 374             if( !shred->run( this ) )
 375             {
 376                 this->free( shred, TRUE );
 377                 shred = NULL;
 378                 if( !m_num_shreds && m_halt ) goto vm_stop;
 379             }
 380         }
 381
 382         // advance the shreduler
 383         m_shreduler->advance();
 384
 385         // process messages
 386         while( m_msg_buffer->get( &msg, 1 ) )
 387             process_msg( msg );
 388     }
 389
 390 // vm stop here
 391 vm_stop:
 392     m_running = FALSE;
 393
 394     return TRUE;
 395 }
 396
 397
 398
 399
 400 //-----------------------------------------------------------------------------
 401 // name: pause()
 402 // desc: ...
 403 //-----------------------------------------------------------------------------
 404 t_CKBOOL Chuck_VM::pause( )
 405 {
 406     m_running = FALSE;
 407
 408     return TRUE;
 409 }
 410
 411
 412
 413
 414 //-----------------------------------------------------------------------------
 415 // name: stop()
 416 // desc: ...
 417 //-----------------------------------------------------------------------------
 418 t_CKBOOL Chuck_VM::stop( )
 419 {
 420     m_running = FALSE;
 421     Digitalio::m_end = TRUE;
 422
 423     return TRUE;
 424 }
 425
 426
 427
 428
 429 //-----------------------------------------------------------------------------
 430 // name: gc
 431 // desc: ...
 432 //-----------------------------------------------------------------------------
 433 void Chuck_VM::gc( t_CKUINT amount )
 434 {
 435 }
 436
 437
 438
 439
 440 //-----------------------------------------------------------------------------
 441 // name: gc
 442 // desc: ...
 443 //-----------------------------------------------------------------------------
 444 void Chuck_VM::gc( )
 445 {
 446 }
 447
 448
 449
 450
 451 //-----------------------------------------------------------------------------
 452 // name: queue_msg()
 453 // desc: ...
 454 //-----------------------------------------------------------------------------
 455 t_CKBOOL Chuck_VM::queue_msg( Chuck_Msg * msg, int count )
 456 {
 457     m_msg_buffer->put( &msg, count );
 458     return TRUE;
 459 }
 460
 461
 462
 463
 464 //-----------------------------------------------------------------------------
 465 // name: get_reply()
 466 // desc: ...
 467 //-----------------------------------------------------------------------------
 468 Chuck_Msg * Chuck_VM::get_reply( )
 469 {
 470     Chuck_Msg * msg = NULL;
 471     m_reply_buffer->get( &msg, 1 );
 472     return msg;
 473 }
 474
 475
 476
 477
 478 //-----------------------------------------------------------------------------
 479 // name: process_msg()
 480 // desc: ...
 481 //-----------------------------------------------------------------------------
 482 t_CKUINT Chuck_VM::process_msg( Chuck_Msg * msg )
 483 {
 484     t_CKUINT retval = 0xfffffff0;
 485
 486     if( msg->type == MSG_REPLACE )
 487     {
 488         Chuck_VM_Shred * out = m_shreduler->lookup( msg->param );
 489         if( !out )
 490         {
 491             EM_error3( "[chuck](VM): error replacing shred: no shred with id %i...",
 492                        msg->param );
 493             retval = 0;
 494             goto done;
 495         }
 496
 497         Chuck_VM_Shred * shred = msg->shred;
 498         if( !shred )
 499         {
 500             shred = new Chuck_VM_Shred;
 501             shred->initialize( msg->code );
 502             shred->name = msg->code->name;
 503         }
 504         // set the current time
 505         shred->start = m_shreduler->now_system;
 506         // set the id
 507         shred->id = msg->param;
 508
 509         // replace
 510         if( m_shreduler->replace( out, shred ) )
 511         {
 512             EM_error3( "[chuck](VM): replacing shred %i (%s) with %i (%s)...",
 513                        out->id, mini(out->name.c_str()), shred->id, mini(shred->name.c_str()) );
 514             this->free( out, TRUE, FALSE );
 515             retval = shred->id;
 516             goto done;
 517         }
 518         else
 519         {
 520             EM_error3( "[chuck](VM): shreduler ERROR replacing shred %i...",
 521                        out->id );
 522             delete shred;
 523             retval = 0;
 524             goto done;
 525         }
 526     }
 527     else if( msg->type == MSG_REMOVE )
 528     {
 529         if( msg->param == 0xffffffff )
 530         {
 531             if( !this->m_num_shreds)
 532             {
 533                 EM_error3( "[chuck](VM): no shreds to remove..." );
 534                 retval = 0;
 535                 goto done;
 536             }
 537
 538             t_CKUINT id = m_shred_id;
 539             Chuck_VM_Shred * shred = NULL;
 540             while( id >= 0 && m_shreduler->remove( shred = m_shreduler->lookup( id ) ) == 0 )
 541                 id--;
 542             if( id >= 0 )
 543             {
 544                 EM_error3( "[chuck](VM): removing recent shred: %i (%s)...",
 545                            id, mini(shred->name.c_str()) );
 546                 this->free( shred, TRUE );
 547                 retval = id;
 548             }
 549             else
 550             {
 551                 EM_error3( "[chuck](VM): no shreds removed..." );
 552                 retval = 0;
 553                 goto done;
 554             }
 555         }
 556         else
 557         {
 558             Chuck_VM_Shred * shred = m_shreduler->lookup( msg->param );
 559             if( !shred )
 560             {
 561                 EM_error3( "[chuck](VM): cannot remove: no shred with id %i...",
 562                            msg->param );
 563                 retval = 0;
 564                 goto done;
 565             }
 566             if( !m_shreduler->remove( m_shreduler->lookup( msg->param ) ) )
 567             {
 568                 EM_error3( "[chuck](VM): shreduler: cannot remove shred %i...",
 569                            msg->param );
 570                 retval = 0;
 571                 goto done;
 572             }
 573             EM_error3( "[chuck](VM): removing shred: %i (%s)...",
 574                        msg->param, mini(shred->name.c_str()) );
 575             this->free( shred, TRUE );
 576             retval = msg->param;
 577         }
 578     }
 579     else if( msg->type == MSG_REMOVEALL )
 580     {
 581         t_CKUINT id = m_shred_id;
 582         EM_error3( "[chuck](VM): removing all (%i) shreds...", m_num_shreds );
 583         Chuck_VM_Shred * shred = NULL;
 584
 585         while( m_num_shreds && id >= 0 )
 586         {
 587             if( m_shreduler->remove( shred = m_shreduler->lookup( id ) ) )
 588                 delete shred;
 589             id--;
 590         }
 591
 592         m_shred_id = 0;
 593         m_num_shreds = 0;
 594     }
 595     else if( msg->type == MSG_ADD )
 596     {
 597         t_CKUINT id = 0;
 598         if( msg->shred ) id = this->spork( msg->shred )->id;
 599         else id = this->spork( msg->code, NULL )->id;
 600
 601         const char * s = ( msg->shred ? msg->shred->name.c_str() : msg->code->name.c_str() );
 602         EM_error3( "[chuck](VM): sporking incoming shred: %i (%s)...", id, mini(s) );
 603         retval = id;
 604         goto done;
 605     }
 606     else if( msg->type == MSG_KILL )
 607     {
 608         EM_error3( "[chuck](VM): KILL received...." );
 609         exit( 1 );
 610     }
 611     else if( msg->type == MSG_STATUS )
 612     {
 613         m_shreduler->status();
 614     }
 615     else if( msg->type == MSG_TIME )
 616     {
 617         float srate = (float)Digitalio::sampling_rate();
 618         fprintf( stderr, "[chuck](VM): the values of now:\n" );
 619         fprintf( stderr, "  now = %i (samp)\n", m_shreduler->now_system );
 620         fprintf( stderr, "      = %.6f (second)\n", m_shreduler->now_system / srate );
 621         fprintf( stderr, "      = %.6f (minute)\n", m_shreduler->now_system / srate / 60.0f );
 622         fprintf( stderr, "      = %.6f (hour)\n", m_shreduler->now_system / srate / 60.0f / 60.0f );
 623         fprintf( stderr, "      = %.6f (day)\n", m_shreduler->now_system / srate / 60.0f / 60.0f / 24.0f );
 624         fprintf( stderr, "      = %.6f (week)\n", m_shreduler->now_system / srate / 60.0f / 60.0f / 24.0f / 7.0f );
 625     }
 626
 627 done:
 628
 629     if( msg->reply )
 630     {
 631         msg->replyA = retval;
 632         m_reply_buffer->put( &msg, 1 );
 633     }
 634     else
 635         SAFE_DELETE(msg);
 636
 637     return retval;
 638 }
 639
 640
 641
 642
 643 //-----------------------------------------------------------------------------
 644 // name: next_id()
 645 // desc: ...
 646 //-----------------------------------------------------------------------------
 647 t_CKUINT Chuck_VM::next_id( )
 648 {
 649     return ++m_shred_id;
 650 }
 651
 652
 653
 654
 655 //-----------------------------------------------------------------------------
 656 // name: shreduler()
 657 // desc: ...
 658 //-----------------------------------------------------------------------------
 659 Chuck_VM_Shreduler * Chuck_VM::shreduler( ) const
 660 {
 661     return m_shreduler;
 662 }
 663
 664
 665
 666
 667 //-----------------------------------------------------------------------------
 668 // name: bbq()
 669 // desc: ...
 670 //-----------------------------------------------------------------------------
 671 BBQ * Chuck_VM::bbq( ) const
 672 {
 673     return m_bbq;
 674 }
 675
 676
 677
 678
 679 //-----------------------------------------------------------------------------
 680 // name: srate()
 681 // desc: ...
 682 //-----------------------------------------------------------------------------
 683 t_CKUINT Chuck_VM::srate() const
 684 {
 685     return (t_CKUINT)Digitalio::sampling_rate();
 686 }
 687
 688
 689
 690
 691 //-----------------------------------------------------------------------------
 692 // name: fork()
 693 // desc: ...
 694 //-----------------------------------------------------------------------------
 695 Chuck_VM_Shred * Chuck_VM::fork( Chuck_VM_Code * code )
 696 {
 697     return NULL;
 698 }
 699
 700
 701
 702
 703 //-----------------------------------------------------------------------------
 704 // name: spork()
 705 // desc: ...
 706 //-----------------------------------------------------------------------------
 707 Chuck_VM_Shred * Chuck_VM::spork( Chuck_VM_Code * code, Chuck_VM_Shred * parent )
 708 {
 709     // allocate a new shred
 710     Chuck_VM_Shred * shred = new Chuck_VM_Shred;
 711     // initialize the shred (default stack size)
 712     shred->initialize( code );
 713     // set the name
 714     shred->name = code->name;
 715     // set the parent
 716     shred->parent = parent;
 717     // spork it
 718     this->spork( shred );
 719
 720     return shred;
 721 }
 722
 723
 724
 725
 726 //-----------------------------------------------------------------------------
 727 // name: spork()
 728 // desc: ...
 729 //-----------------------------------------------------------------------------
 730 Chuck_VM_Shred * Chuck_VM::spork( Chuck_VM_Shred * shred )
 731 {
 732     // set the current time
 733     shred->start = m_shreduler->now_system;
 734     // set the now
 735     shred->now = shred->wake_time = m_shreduler->now_system;
 736     // set the id
 737     shred->id = next_id();
 738     // add it to the parent
 739     if( shred->parent )
 740         shred->parent->children[shred->id] = shred;
 741     // shredule it
 742     m_shreduler->shredule( shred );
 743     // count
 744     m_num_shreds++;
 745
 746     return shred;
 747 }
 748
 749
 750
 751
 752 //-----------------------------------------------------------------------------
 753 // name: free()
 754 // desc: ...
 755 //-----------------------------------------------------------------------------
 756 t_CKBOOL Chuck_VM::free( Chuck_VM_Shred * shred, t_CKBOOL cascade, t_CKBOOL dec )
 757 {
 758     assert( cascade );
 759
 760     // mark this done
 761     shred->is_done = TRUE;
 762
 763     // free the children
 764     t_CKINT size = shred->children.size();
 765     if( size )
 766     {
 767         vector<Chuck_VM_Shred *> list; list.resize( size );
 768         map<t_CKUINT, Chuck_VM_Shred *>::iterator iter; t_CKINT i = 0;
 769         for( iter = shred->children.begin(); iter != shred->children.end(); iter++ )
 770             list[i++] = (*iter).second;
 771         for( i = 0; i < size; i++ )
 772             this->free( list[i], cascade );
 773     }
 774
 775     // make sure it's done
 776     assert( shred->children.size() == 0 );
 777
 778     // tell parent
 779     if( shred->parent )
 780         shred->parent->children.erase( shred->id );
 781
 782     // free!
 783     m_shreduler->remove( shred );
 784     SAFE_DELETE( shred );
 785     if( dec ) m_num_shreds--;
 786     if( !m_num_shreds ) m_shred_id = 0;
 787
 788     return TRUE;
 789 }
 790
 791
 792
 793
 794 //-----------------------------------------------------------------------------
 795 // name: dll_load()
 796 // desc: ...
 797 //-----------------------------------------------------------------------------
 798 Chuck_DLL * Chuck_VM::dll_load( const char * path, const char * id )
 799 {
 800     Chuck_DLL * dll = m_dlls[path];
 801     if( !dll )
 802     {
 803         dll = new Chuck_DLL(id);
 804         if( !dll ) return NULL;
 805
 806         // load the dll
 807         if( !dll->load( path ) )
 808         {
 809             m_last_error = dll->last_error();
 810             delete dll;
 811             return NULL;
 812         }
 813
 814         m_dlls[path] = dll;
 815     }
 816
 817     return dll;
 818 }
 819
 820
 821
 822
 823 //-----------------------------------------------------------------------------
 824 // name: dll_unload()
 825 // desc: ...
 826 //-----------------------------------------------------------------------------
 827 t_CKBOOL Chuck_VM::dll_unload( Chuck_DLL *& dll )
 828 {
 829     if( !dll ) return TRUE;
 830
 831     // deallocate
 832     dll->unload();
 833     delete dll;
 834     dll = NULL;
 835
 836     return TRUE;
 837 }
 838
 839
 840
 841
 842 //-----------------------------------------------------------------------------
 843 // name: dll_clear()
 844 // desc: ...
 845 //-----------------------------------------------------------------------------
 846 void Chuck_VM::dll_clear()
 847 {
 848     map<string, Chuck_DLL *>::iterator iter;
 849     for( iter = m_dlls.begin(); iter != m_dlls.end(); iter++ )
 850     {
 851         (*iter).second->unload();
 852         delete (*iter).second;
 853     }
 854
 855     m_dlls.clear();
 856 }
 857
 858
 859
 860
 861 //-----------------------------------------------------------------------------
 862 // name: Chuck_VM_Stack()
 863 // desc: ...
 864 //-----------------------------------------------------------------------------
 865 Chuck_VM_Stack::Chuck_VM_Stack()
 866 {
 867     stack = sp = sp_max = NULL;
 868     prev = next = NULL;
 869     m_is_init = FALSE;
 870 }
 871
 872
 873
 874
 875 //-----------------------------------------------------------------------------
 876 // name: ~Chuck_VM_Stack()
 877 // desc: ...
 878 //-----------------------------------------------------------------------------
 879 Chuck_VM_Stack::~Chuck_VM_Stack()
 880 {
 881     this->shutdown();
 882 }
 883
 884
 885
 886
 887 //-----------------------------------------------------------------------------
 888 // name: Chuck_VM_Code()
 889 // desc: ...
 890 //-----------------------------------------------------------------------------
 891 Chuck_VM_Code::Chuck_VM_Code()
 892 {
 893     instr = NULL;
 894     num_instr = 0;
 895 }
 896
 897
 898
 899
 900 //-----------------------------------------------------------------------------
 901 // name: ~Chuck_VM_Code()
 902 // desc: ...
 903 //-----------------------------------------------------------------------------
 904 Chuck_VM_Code::~Chuck_VM_Code()
 905 {
 906     if( instr )
 907         delete [] instr;
 908
 909     num_instr = 0;
 910 }
 911
 912
 913
 914
 915 //-----------------------------------------------------------------------------
 916 // name: initialize()
 917 // desc: ...
 918 //-----------------------------------------------------------------------------
 919 t_CKBOOL Chuck_VM_Stack::initialize( t_CKUINT size )
 920 {
 921     if( m_is_init )
 922         return FALSE;
 923
 924     // allocate stack
 925     stack = new t_CKBYTE[size];
 926     if( !stack )
 927         return FALSE;
 928
 929     // zero
 930     memset( stack, 0, size );
 931
 932     // set the sp
 933     sp = stack;
 934     sp_max = sp + size;
 935
 936     // set flag and return
 937     return m_is_init = TRUE;
 938 }
 939
 940
 941
 942
 943 //-----------------------------------------------------------------------------
 944 // name: shutdown()
 945 // desc: ...
 946 //-----------------------------------------------------------------------------
 947 t_CKBOOL Chuck_VM_Stack::shutdown()
 948 {
 949     if( !m_is_init )
 950         return FALSE;
 951
 952     // free the stack
 953     SAFE_DELETE_ARRAY( stack );
 954     sp = sp_max = NULL;
 955
 956     // set the flag to false
 957     m_is_init = FALSE;
 958
 959     return TRUE;
 960 }
 961
 962
 963
 964
 965 //-----------------------------------------------------------------------------
 966 // name: Chuck_VM_Shred()
 967 // desc: ...
 968 //-----------------------------------------------------------------------------
 969 Chuck_VM_Shred::Chuck_VM_Shred()
 970 {
 971     mem = new Chuck_VM_Stack;
 972     reg = new Chuck_VM_Stack;
 973     code = NULL;
 974     next = prev = NULL;
 975     instr = NULL;
 976     parent = NULL;
 977 }
 978
 979
 980
 981
 982 //-----------------------------------------------------------------------------
 983 // name: ~Chuck_VM_Shred()
 984 // desc: ...
 985 //-----------------------------------------------------------------------------
 986 Chuck_VM_Shred::~Chuck_VM_Shred()
 987 {
 988     this->shutdown();
 989 }
 990
 991
 992
 993
 994 //-----------------------------------------------------------------------------
 995 // name: initialize()
 996 // desc: ...
 997 //-----------------------------------------------------------------------------
 998 t_CKBOOL Chuck_VM_Shred::initialize( Chuck_VM_Code * c,
 999                                      t_CKUINT mem_stack_size,
1000                                      t_CKUINT reg_stack_size )
1001 {
1002     // allocate mem and reg
1003     if( !mem->initialize( mem_stack_size ) ) return FALSE;
1004     if( !reg->initialize( reg_stack_size ) ) return FALSE;
1005
1006     // program counter
1007     pc = 0;
1008     next_pc = 1;
1009     // code pointer
1010     code = c;
1011     // shred done
1012     is_done = FALSE;
1013     // shred running
1014     is_running = FALSE;
1015     // set the instr
1016     instr = c->instr;
1017     // zero out the id
1018     id = 0;
1019
1020     return TRUE;
1021 }
1022
1023
1024
1025
1026 //-----------------------------------------------------------------------------
1027 // name: shutdown()
1028 // desc: ...
1029 //-----------------------------------------------------------------------------
1030 t_CKBOOL Chuck_VM_Shred::shutdown()
1031 {
1032     // get iterator to our map
1033     map<Chuck_UGen *, Chuck_UGen *>::iterator iter = m_ugen_map.begin();
1034     while( iter != m_ugen_map.end() )
1035     {
1036         (*iter).first->disconnect( TRUE );
1037         iter++;
1038     }
1039     m_ugen_map.clear();
1040
1041     SAFE_DELETE( mem );
1042     SAFE_DELETE( reg );
1043
1044     // TODO: is this right?
1045     code = NULL;
1046     // what to do with next and prev?
1047
1048     return TRUE;
1049 }
1050
1051
1052
1053
1054 //-----------------------------------------------------------------------------
1055 // name: add()
1056 // desc: ...
1057 //-----------------------------------------------------------------------------
1058 t_CKBOOL Chuck_VM_Shred::add( Chuck_UGen * ugen )
1059 {
1060     if( m_ugen_map[ugen] )
1061         return FALSE;
1062
1063     m_ugen_map[ugen] = ugen;
1064     return TRUE;
1065 }
1066
1067
1068
1069
1070 //-----------------------------------------------------------------------------
1071 // name: remove()
1072 // desc: ...
1073 //-----------------------------------------------------------------------------
1074 t_CKBOOL Chuck_VM_Shred::remove( Chuck_UGen * ugen )
1075 {
1076     if( !m_ugen_map[ugen] )
1077         return FALSE;
1078
1079     // remove it
1080     m_ugen_map.erase( ugen );
1081     return TRUE;
1082 }
1083
1084
1085
1086
1087 //-----------------------------------------------------------------------------
1088 // name: run()
1089 // desc: ...
1090 //-----------------------------------------------------------------------------
1091 t_CKBOOL Chuck_VM_Shred::run( Chuck_VM * vm )
1092 {
1093     // get the code
1094     instr = code->instr;
1095     is_running = TRUE;
1096
1097     // go!
1098     while( is_running )
1099     {
1100         // execute the instruction
1101         instr[pc]->execute( vm, this );
1102
1103         // set to next_pc;
1104         pc = next_pc;
1105         next_pc++;
1106     }
1107
1108     // is the shred finished
1109     return !is_done;
1110 }
1111
1112
1113
1114
1115 //-----------------------------------------------------------------------------
1116 // name: Chuck_VM_Shreduler()
1117 // desc: ...
1118 //-----------------------------------------------------------------------------
1119 Chuck_VM_Shreduler::Chuck_VM_Shreduler()
1120 {
1121     shred_list = NULL;
1122     now_system = 0;
1123 }
1124
1125
1126
1127
1128 //-----------------------------------------------------------------------------
1129 // name: ~Chuck_VM_Shreduler()
1130 // desc: ...
1131 //-----------------------------------------------------------------------------
1132 Chuck_VM_Shreduler::~Chuck_VM_Shreduler()
1133 {
1134     this->shutdown();
1135 }
1136
1137
1138
1139
1140 //-----------------------------------------------------------------------------
1141 // name: initialize()
1142 // desc: ...
1143 //-----------------------------------------------------------------------------
1144 t_CKBOOL Chuck_VM_Shreduler::initialize()
1145 {
1146     return TRUE;
1147 }
1148
1149
1150
1151
1152 //-----------------------------------------------------------------------------
1153 // name: shutdown()
1154 // desc: ...
1155 //-----------------------------------------------------------------------------
1156 t_CKBOOL Chuck_VM_Shreduler::shutdown()
1157 {
1158     return TRUE;
1159 }
1160
1161
1162
1163
1164 //-----------------------------------------------------------------------------
1165 // name: shredule()
1166 // desc: ...
1167 //-----------------------------------------------------------------------------
1168 t_CKBOOL Chuck_VM_Shreduler::shredule( Chuck_VM_Shred * shred )
1169 {
1170     return this->shredule( shred, now_system );
1171 }
1172
1173
1174
1175
1176 //-----------------------------------------------------------------------------
1177 // name: shredule()
1178 // desc: ...
1179 //-----------------------------------------------------------------------------
1180 t_CKBOOL Chuck_VM_Shreduler::shredule( Chuck_VM_Shred * shred,
1181                                        t_CKTIME wake_time )
1182 {
1183     // sanity check
1184     if( shred->prev || shred->next )
1185     {
1186         // something is really wrong here - no shred can be
1187         // shreduled more than once
1188         return FALSE;
1189     }
1190
1191     // sanity check
1192     if( wake_time < this->now_system )
1193     {
1194         // trying to enqueue on a time that is less than now
1195         return FALSE;
1196     }
1197
1198     shred->wake_time = wake_time;
1199
1200     // list empty
1201     if( !shred_list )
1202         shred_list = shred;
1203     else
1204     {
1205         // pointers to the shred queue
1206         Chuck_VM_Shred * curr = shred_list;
1207         Chuck_VM_Shred * prev = NULL;
1208
1209         while( curr )
1210         {
1211             // found the place to insert
1212             if( curr->wake_time > wake_time )
1213                 break;
1214
1215             prev = curr;
1216             curr = curr->next;
1217         }
1218
1219         if( !prev )
1220         {
1221             shred->next = shred_list;
1222             if( shred_list ) shred_list->prev = shred;
1223             shred_list = shred;
1224         }
1225         else
1226         {
1227             // insert the shred in sorted order
1228             shred->next = prev->next;
1229             shred->prev = prev;
1230             if( prev->next ) prev->next->prev = shred;
1231             prev->next = shred;
1232         }
1233     }
1234
1235     return TRUE;
1236 }
1237
1238
1239
1240 //-----------------------------------------------------------------------------
1241 // name: advance()
1242 // desc: ...
1243 //-----------------------------------------------------------------------------
1244 void Chuck_VM_Shreduler::advance( )
1245 {
1246     // advance system 'now'
1247     this->now_system += 1;
1248
1249     // tick the dac
1250     SAMPLE l, r;
1251     BBQ * audio = this->bbq;
1252
1253     // tick in
1254     if( audio )
1255     {
1256         audio->digi_in()->tick_in( &l, &r );
1257         m_adc[0].m_current = .5f * ( l + r ) * m_adc[0].m_gain;
1258         // m_adc[1].m_current = r * m_adc[1].m_gain;
1259     }
1260
1261     // dac
1262     m_dac[0].system_tick( this->now_system );
1263     //m_dac[1].system_tick( this->now_system );
1264     l = m_dac[0].m_current;
1265     //r = m_dac[1].m_current;
1266     l *= .5f;
1267
1268     // suck samples
1269     m_bunghole->system_tick( this->now_system );
1270
1271     // tick
1272     if( audio )
1273         audio->digi_out()->tick_out( l, l );
1274 }
1275
1276
1277
1278
1279 //-----------------------------------------------------------------------------
1280 // name: get()
1281 // desc: ...
1282 //-----------------------------------------------------------------------------
1283 Chuck_VM_Shred * Chuck_VM_Shreduler::get( )
1284 {
1285     Chuck_VM_Shred * shred = shred_list;
1286
1287     // list empty
1288     if( !shred )
1289         return NULL;
1290
1291     // TODO: should this be <=?
1292     if( shred->wake_time <= ( this->now_system + .5 ) )
1293     {
1294         // if( shred->wake_time < this->now_system )
1295         //    assert( false );
1296
1297         shred_list = shred->next;
1298         shred->next = NULL;
1299         shred->prev = NULL;
1300
1301         if( shred_list )
1302             shred_list->prev = NULL;
1303
1304         return shred;
1305     }
1306
1307     return NULL;
1308 }
1309
1310
1311
1312 //-----------------------------------------------------------------------------
1313 // name: replace()
1314 // desc: ...
1315 //-----------------------------------------------------------------------------
1316 t_CKBOOL Chuck_VM_Shreduler::replace( Chuck_VM_Shred * out, Chuck_VM_Shred * in )
1317 {
1318     // sanity check
1319     if( !out || !in )
1320         return FALSE;
1321
1322     if( !out->prev )
1323         shred_list = in;
1324     else
1325         out->prev->next = in;
1326
1327     if( out->next )
1328         out->next->prev = in;
1329
1330     in->next = out->next;
1331     in->prev = out->prev;
1332
1333     out->next = out->prev = NULL;
1334
1335     in->wake_time = out->wake_time;
1336     in->start = in->wake_time;
1337
1338     return TRUE;
1339 }
1340
1341
1342
1343
1344 //-----------------------------------------------------------------------------
1345 // name: remove()
1346 // desc: ...
1347 //-----------------------------------------------------------------------------
1348 t_CKBOOL Chuck_VM_Shreduler::remove( Chuck_VM_Shred * out )
1349 {
1350     // sanity check
1351     if( !out || ( !out->prev && !out->prev && out != shred_list ) )
1352         return FALSE;
1353
1354     if( !out->prev )
1355         shred_list = out->next;
1356     else
1357         out->prev->next = out->next;
1358
1359     if( out->next )
1360         out->next->prev = out->prev;
1361
1362     out->next = out->prev = NULL;
1363
1364     return TRUE;
1365 }
1366
1367
1368
1369
1370 //-----------------------------------------------------------------------------
1371 // name: get()
1372 // desc: ...
1373 //-----------------------------------------------------------------------------
1374 Chuck_VM_Shred * Chuck_VM_Shreduler::lookup( t_CKUINT id )
1375 {
1376     Chuck_VM_Shred * shred = shred_list;
1377
1378     // list empty
1379     if( !shred )
1380         return NULL;
1381
1382     while( shred )
1383     {
1384         if( shred->id == id )
1385             return shred;
1386
1387         shred = shred->next;
1388     }
1389
1390     return NULL;
1391 }
1392
1393
1394
1395
1396 //-----------------------------------------------------------------------------
1397 // name: status()
1398 // desc: ...
1399 //-----------------------------------------------------------------------------
1400 void Chuck_VM_Shreduler::status( )
1401 {
1402     Chuck_VM_Shred * shred = shred_list;
1403
1404     t_CKUINT srate = Digitalio::sampling_rate();
1405     t_CKUINT s = (t_CKUINT)now_system;
1406     t_CKUINT h = s/(srate*3600);
1407     s = s - (h*(srate*3600));
1408     t_CKUINT m = s / (srate*60);
1409     s = s - (m*(srate*60));
1410     t_CKUINT sec = s / srate;
1411     s = s - (sec*(srate));
1412     float millisecond = s / (float)(srate) * 1000.0f;
1413     fprintf( stdout, "[chuck](VM): status (now == %ih%im%is, %.1f samps) ...\n",
1414              h, m, sec, now_system );
1415
1416     char buffer[1024];
1417     while( shred )
1418     {
1419         char * s = buffer, * ss = buffer;
1420         strcpy( buffer, shred->name.c_str() );
1421         while( *s++ ) if( *s == '/' ) { ss = s+1; }
1422
1423         fprintf( stdout,
1424             "    [shred id]: %i  [source]: %s  [spork time]: %.2fs ago\n",
1425             shred->id, mini( shred->name.c_str() ),
1426             (now_system-shred->start)/(float)Digitalio::sampling_rate() );
1427         shred = shred->next;
1428     }
1429 }