Mercurial > cgi-bin > hgwebdir.cgi > VMS > VMS_Implementations > VMS_impls > VMS__MC_shared_impl

comparison AnimationMaster.c @ 266:a5fa1e087c7e

find changesets by author, revision, files, or words in the commit message
Save checkpoint to come back to -- about to mangle AnimationMaster.c
author Sean Halle <seanhalle@yahoo.com>
date Thu, 25 Oct 2012 23:35:36 -0700
parents dafae55597ce
children 608833ae2c5d
comparison
equal deleted inserted replaced
10:dd554750655b 11:cfb14d4ffc6d
332 332
333 goto AssignWork; 333 goto AssignWork;
334 } 334 }
335 else //is a task, and just suspended 335 else //is a task, and just suspended
336 { //turn slot slave into free task slave & make replacement 336 { //turn slot slave into free task slave & make replacement
337 if( slave->typeOfVP == TaskSlotSlv ) changeSlvType(); 337 if( slave->typeOfVP == SlotTaskSlv ) changeSlvType();
338 338
339 //goto normal slave request handling 339 //goto normal slave request handling
340 goto SlaveReqHandling; 340 goto SlaveReqHandling;
341 } 341 }
342 } 342 }
558 558
559 goto AssignWork; 559 goto AssignWork;
560 } 560 }
561 else //is a task, and just suspended 561 else //is a task, and just suspended
562 { //turn slot slave into free task slave & make replacement 562 { //turn slot slave into free task slave & make replacement
563 if( slave->typeOfVP == TaskSlotSlv ) changeSlvType(); 563 if( slave->typeOfVP == SlotTaskSlv ) changeSlvType();
564 564
565 //goto normal slave request handling 565 //goto normal slave request handling
566 goto SlaveReqHandling; 566 goto SlaveReqHandling;
567 } 567 }
568 } 568 }
696 //do task end handler, which is registered separately 696 //do task end handler, which is registered separately
697 //note, end hdlr may use semantic data from reqst.. 697 //note, end hdlr may use semantic data from reqst..
698 //get end-task handler 698 //get end-task handler
699 699
700 RequestHandler 700 RequestHandler
701 taskEndHandler = slave->metaTask->reqHandler; 701 taskEndHandler = slave->request->handler;
702 semanticEnv = PR_int__give_sem_env_for_slave( slave, 702 semanticEnv = PR_int__give_sem_env_for_slave( slave,
703 slave->request->langMagicNumber ); 703 slave->request->langMagicNumber );
704 (*taskEndHandler)( slave, semanticEnv ); 704 (*taskEndHandler)( slave, semanticEnv );
705 705
706 goto AssignWork; 706 goto AssignWork;
707 } 707 }
708 case TaskCreate: 708 case TaskCreate:
709 { PRHandle_CreateTask( slave ); 709 { PRHandle_CreateTask( slave );
710 justCopied_check;
711 RequestHandler 710 RequestHandler
712 taskCreateHandler = slave->metaTask->reqHandler; 711 taskCreateHandler = slave->request->handler;
713 semanticEnv = PR_int__give_sem_env_for_slave( slave, 712 semanticEnv = PR_int__give_sem_env_for_slave( slave,
714 slave->request->langMagicNumber ); 713 slave->request->langMagicNumber );
715 (*taskCreateHandler)( slave, semanticEnv ); 714 (*taskCreateHandler)( slave, semanticEnv ); //resumes creating slave
716
717 want_to_resume_creating_slave;
718 goto AssignWork; 715 goto AssignWork;
719 } 716 }
720 default: 717 default:
721 { //is a task, and just suspended, so tied to a free task slave 718 { //is a task, and just suspended, so tied to a free task slave
722 //First turn slot slave into free task slave & make replacement 719 //First turn slot slave into free task slave & make replacement
723 if( slave->typeOfVP == TaskSlotSlv ) 720 if( slave->typeOfVP == SlotTaskSlv )
724 replaceWithNewSlotSlv( slave, slave->processSlaveIsIn->processEnv ); 721 replaceWithNewSlotSlv( slave, slave->processSlaveIsIn->processEnv );
725 722
726 //goto normal slave request handling 723 //goto normal slave request handling
727 goto SlaveReqHandling; 724 goto SlaveReqHandling;
728 } 725 }
784 * either a recycled free task slave that finished it's task and has been 781 * either a recycled free task slave that finished it's task and has been
785 * idle in the recycle queue, or else create a new slave to be the slot slave. 782 * idle in the recycle queue, or else create a new slave to be the slot slave.
786 *The master only calls this with a slot slave that needs to be replaced. 783 *The master only calls this with a slot slave that needs to be replaced.
787 */ 784 */
788 inline void 785 inline void
789 replaceWithNewSlotSlv( SlaveVP *requestingSlv, PRProcessEnv *processEnv ) 786 replaceWithNewSlotSlv( SlaveVP *requestingSlv, PRProcess *process )
790 { SlaveVP *newSlotSlv; 787 { SlaveVP *newSlotSlv;
791 VSsSemData *semData; 788
792
793 fixMe__still_VSs_stuff_in_here;
794 //get a new slave to be the slot slave 789 //get a new slave to be the slot slave
795 newSlotSlv = readPrivQ( processEnv->freeTaskSlvRecycleQ ); 790 newSlotSlv = readPrivQ( process->freeTaskSlvRecycleQ );
796 if( newSlotSlv == NULL ) 791 if( newSlotSlv == NULL )
797 { newSlotSlv = PR_int__create_slaveVP( &idle_fn, NULL, processEnv, 0); 792 { newSlotSlv = PR_int__create_slaveVP( &idle_fn, NULL, process, 0);
798 //just made a new free task slave, so count it 793 //just made a new free task slave, so count it
799 processEnv->numLiveFreeTaskSlvs += 1; 794 process->numLiveFreeTaskSlvs += 1;
800 } 795 }
801 796
802 //set slave values to make it the slot slave 797 //set slave values to make it the slot slave
803 newSlotSlv->metaTask = NULL; 798 newSlotSlv->metaTask = NULL;
804 newSlotSlv->typeOfVP = TaskSlotSlv; 799 newSlotSlv->typeOfVP = SlotTaskSlv;
805 newSlotSlv->needsTaskAssigned = TRUE; 800 newSlotSlv->needsTaskAssigned = TRUE;
806 801
807 //a slot slave is pinned to a particular slot on a particular core 802 //a slot slave is pinned to a particular slot on a particular core
808 //Note, this happens before the request is seen by handler, so nothing 803 //Note, this happens before the request is seen by handler, so nothing
809 // has had a chance to change the coreAnimatedBy or anything else.. 804 // has had a chance to change the coreAnimatedBy or anything else..
811 newSlotSlv->coreAnimatedBy = requestingSlv->coreAnimatedBy; 806 newSlotSlv->coreAnimatedBy = requestingSlv->coreAnimatedBy;
812 807
813 //put it into the slot slave matrix 808 //put it into the slot slave matrix
814 int32 slotNum = requestingSlv->animSlotAssignedTo->slotIdx; 809 int32 slotNum = requestingSlv->animSlotAssignedTo->slotIdx;
815 int32 coreNum = requestingSlv->coreAnimatedBy; 810 int32 coreNum = requestingSlv->coreAnimatedBy;
816 processEnv->slotTaskSlvs[coreNum][slotNum] = newSlotSlv; 811 process->slotTaskSlvs[coreNum][slotNum] = newSlotSlv;
817 812
818 //Fix up requester, to be an extra slave now (but not an ended one) 813 //Fix up requester, to be an extra slave now (but not an ended one)
819 // because it's active, doesn't go into freeTaskSlvRecycleQ 814 // because it's active, doesn't go into freeTaskSlvRecycleQ
820 requestingSlv->typeOfVP = FreeTaskSlv; 815 requestingSlv->typeOfVP = FreeTaskSlv;
816 check_if_need_to_change_metaTask_type_or_something;
821 } 817 }
822 818
823 819
824 820
825 /*This does: 821 /*This does:
860 //have work, so reset Done flag (caused by work generated on other core) 856 //have work, so reset Done flag (caused by work generated on other core)
861 if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf 857 if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf
862 process->coreIsDone[coreNum] = FALSE; //don't just write always 858 process->coreIsDone[coreNum] = FALSE; //don't just write always
863 859
864 switch( assignedMetaTask->taskType ) 860 switch( assignedMetaTask->taskType )
865 { case GenericSlave: goto AssignSlave; 861 { case GenericSlave: goto AssignSlave;
866 case ResumedTask: goto AssignSlave; 862 case SuspendedTask: goto AssignSlave;
867 case NewTask: goto AssignNewTask; 863 case AtomicTask: goto AssignNewTask;
868 case default: PR_int__throw_exception( "unknown task type ret by assigner" ); 864 default: PR_int__throw_exception( "unknown task type ret by assigner" );
869 } 865 }
870 } 866 }
871 else 867 else
872 goto NoWork; 868 goto NoWork;
873 } 869 }
877 semEnvs = process->semEnvs; 873 semEnvs = process->semEnvs;
878 numEnvs = process->numSemEnvs; 874 numEnvs = process->numSemEnvs;
879 for( envIdx = 0; envIdx < numEnvs; envIdx++ ) //keep semEnvs in hash AND array 875 for( envIdx = 0; envIdx < numEnvs; envIdx++ ) //keep semEnvs in hash AND array
880 { semEnv = semEnvs[envIdx]; 876 { semEnv = semEnvs[envIdx];
881 if( semEnv->hasWork ) 877 if( semEnv->hasWork )
882 { assigner = semEnv->assigner; 878 { assigner = semEnv->slaveAssigner;
883 assignedMetaTask = (*assigner)( semEnv, slot ); 879 assignedMetaTask = (*assigner)( semEnv, slot );
884 880
885 //have work, so reset Done flag (caused by work generated on other core) 881 //have work, so reset Done flag (caused by work generated on other core)
886 if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf 882 if( process->coreIsDone[coreNum] == TRUE ) //reads are higher perf
887 process->coreIsDone[coreNum] = FALSE; //don't just write always 883 process->coreIsDone[coreNum] = FALSE; //don't just write always
888 884
889 switch( assignedMetaTask->taskType ) 885 switch( assignedMetaTask->taskType )
890 { case GenericSlave: goto AssignSlave; 886 { case GenericSlave: goto AssignSlave;
891 case ResumedTask: goto AssignSlave; 887 case SuspendedTask: goto AssignSlave;
892 case NewTask: goto AssignNewTask; 888 case AtomicTask: goto AssignNewTask;
893 case default: PR_int__throw_exception( "unknown task type ret by assigner" ); 889 default: PR_int__throw_exception( "unknown task type ret by assigner" );
894 } 890 }
895 } 891 }
896 } 892 }
897 893
898 NoWork: 894 NoWork:
899 //No work, if reach here.. 895 //No work, if reach here..
900 //no task, so prune the recycle pool of free task slaves 896 { goto ReturnTheSlv;
901 freeTaskSlv = readPrivQ( process->freeTaskSlvRecycleQ );
902 if( freeTaskSlv != NULL )
903 { //delete, so that bound the num extras, and deliver shutdown cond
904 deleteExtraneousFreeTaskSlv( freeTaskSlv, process );
905 //then return NULL
906 returnSlv = NULL;
907
908 goto ReturnTheSlv;
909 } 897 }
910 else 898
911 { //candidate for shutdown.. all extras dissipated, and no tasks 899 AssignSlave: //Have a metaTask attached to a slave, so get the slave out
912 // and no ready to resume slaves, so no way to generate
913 // more work (on this core -- other core might have work still)
914 if( process->numLiveFreeTaskSlvs == 0 &&
915 process->numLiveGenericSlvs == 0 )
916 { //This core sees no way to generate more tasks, so say it
917 if( process->coreIsDone[coreNum] == FALSE )
918 { process->numCoresDone += 1;
919 process->coreIsDone[coreNum] = TRUE;
920 #ifdef DEBUG__TURN_ON_SEQUENTIAL_MODE
921 process->shutdownInitiated = TRUE;
922
923 #else
924 if( process->numCoresDone == NUM_CORES )
925 { //means no cores have work, and none can generate more
926 process->shutdownInitiated = TRUE;
927 }
928 #endif
929 }
930 }
931 //check if shutdown has been initiated by this or other core
932 if( process->shutdownInitiated )
933 { returnSlv = PR_SS__create_shutdown_slave();
934 }
935 else
936 returnSlv = NULL;
937
938 goto ReturnTheSlv;
939 } //if( freeTaskSlv != NULL )
940
941
942 AssignSlave:
943 { //get slave pointed to by meta task. 900 { //get slave pointed to by meta task.
944 returnSlv = assignedMetaTask->slaveAssignedTo; 901 returnSlv = assignedMetaTask->slaveAssignedTo;
945 902
946 returnSlv->coreAnimatedBy = coreNum; 903 returnSlv->coreAnimatedBy = coreNum;
947 904
1043 1000
1044 process = requestingSlv->processSlaveIsIn; 1001 process = requestingSlv->processSlaveIsIn;
1045 newSlv = PR_int__create_slaveVP(); 1002 newSlv = PR_int__create_slaveVP();
1046 newSlv->typeOfVP = GenericSlv; 1003 newSlv->typeOfVP = GenericSlv;
1047 newSlv->processSlaveIsIn = process; 1004 newSlv->processSlaveIsIn = process;
1048 process->numLiveGenericSlaves += 1; 1005 process->numLiveGenericSlvs += 1;
1049 metaTask = PR_int__create_slave_meta_task(); 1006 metaTask = PR_int__create_slave_meta_task();
1050 metaTask->taskID = req->ID; 1007 metaTask->taskID = req->ID;
1051 metaTask->taskType = GenericSlave; 1008 metaTask->taskType = GenericSlave;
1052 1009
1053 (*req->handler)(newSlv); 1010 (*req->handler)(newSlv);
1071 1028
1072 //do the language's dissipate handler 1029 //do the language's dissipate handler
1073 semEnv = PR_int__give_sem_env_for( slave, slave->request->langMagicNumber ); 1030 semEnv = PR_int__give_sem_env_for( slave, slave->request->langMagicNumber );
1074 (*slave->request->handler)( slave, semEnv ); 1031 (*slave->request->handler)( slave, semEnv );
1075 1032
1076 process->numLiveGenericSlaves -= 1; 1033 process->numLiveGenericSlvs -= 1;
1077 PR_int__dissipate_slaveVP_multilang( slave ); //recycles and resets semDatas 1034 PR_int__dissipate_slaveVP_multilang( slave ); //recycles and resets semDatas
1078 1035
1079 //check End Of Process Condition 1036 //check End Of Process Condition
1080 if( process->numLiveTasks == 0 && 1037 if( process->numLiveTasks == 0 &&
1081 process->numLiveGenericSlaves == 0 ) 1038 process->numLiveGenericSlvs == 0 )
1082 signalEndOfProcess; 1039 signalEndOfProcess;
1083 } 1040 }
1084 1041
1085 /*Create task is a special form, that has PR behavior in addition to plugin 1042 /*Create task is a special form, that has PR behavior in addition to plugin
1086 * behavior. Master calls this first, and this in turn calls the plugin's 1043 * behavior. Master calls this first, and this in turn calls the plugin's
1156 1113
1157 process->numLiveTasks -= 1; 1114 process->numLiveTasks -= 1;
1158 1115
1159 //check End Of Process Condition 1116 //check End Of Process Condition
1160 if( process->numLiveTasks == 0 && 1117 if( process->numLiveTasks == 0 &&
1161 process->numLiveGenericSlaves == 0 ) 1118 process->numLiveGenericSlvs == 0 )
1162 signalEndOfProcessToCoreCtlr; 1119 signalEndOfProcessToCoreCtlr;
1163 } 1120 }
1164 1121
1165 1122