Пример #1
0
void function_3 ( void )
{
  while (1)
  {  	  
	  changePriority ( "fun_one", 4 );
	  changePriority ( "fun_two", 3 );
	  changePriority ( "fun_three",5  );
	  changePriority ( "fun_four", 2 );
      printf ( "fun_3\n" );
      
  }
}
Пример #2
0
static void addToOpenSet (astar_t *astar,
			  int node, 
			  int nodeFrom)
{
	coord_t nodeCoord = getCoord (astar->bounds, node);
	coord_t nodeFromCoord = getCoord (astar->bounds, nodeFrom);

	if (!exists (astar->open, node)) {
		astar->cameFrom[node] = nodeFrom;
		astar->gScores[node] = astar->gScores[nodeFrom] + 
			preciseDistance (nodeFromCoord, nodeCoord);
		insert (astar->open, node, astar->gScores[node] + 
			estimateDistance (nodeCoord, 
					  getCoord (astar->bounds, astar->goal)));
	}
	else if (astar->gScores[node] > 
		 astar->gScores[nodeFrom] + 
		 preciseDistance (nodeFromCoord, nodeCoord)) {
		astar->cameFrom[node] = nodeFrom;
		int oldGScore = astar->gScores[node];
		astar->gScores[node] = astar->gScores[nodeFrom] + 
			preciseDistance (nodeFromCoord, nodeCoord);
		double newPri = priorityOf (astar->open, node)
			- oldGScore
			+ astar->gScores[node];
		changePriority (astar->open, node, newPri);
	}	
}
Пример #3
0
void function_4 ( void )
{
  
  while (1)
  {   
	  changePriority ( "fun_one", 2 );
	  changePriority ( "fun_two", 3 );
	  changePriority ( "fun_three", 4 );
	  changePriority ( "fun_four", 5 );
	//  deleteTask  ( "fun_one" );
	//  deleteTask  ( "fun_two" );
	  deleteTask  ( "fun_three" );
	  deleteTask   ( "fun_four" );
      printf ( "fun_ffffffoooouuurrrr\n" );
      
  }
}
Пример #4
0
bool KMCupsJobManager::doPluginAction(int ID, const QPtrList<KMJob>& jobs)
{
	switch (ID)
	{
		case 0:
			if (jobs.count() == 1)
				return jobIppReport(jobs.getFirst());
			break;
		case 1:
			return changePriority(jobs, true);
		case 2:
			return changePriority(jobs, false);
		case 3:
			return editJobAttributes(jobs.getFirst());
	}
	return false;
}
Пример #5
0
				Thread::Thread(	const nc::string& description, SpThreadProc_t threadProc, nc::uint32_t priority )
					: nc::generic::thread::Thread( description, threadProc, priority )
					, suspendCount_( 0 )
				{
					//threadを構築する。
					pthread_create( &hThread_, NULL, &Thread::functionAdapter, this );

					{
						nc::thread::ScopedLock< nc::thread::Mutex > lock( mtex_ );
						isActive_ = true;
					}

					changePriority( priority_ );
				}
Пример #6
0
static Htop_Reaction actionLowerPriority(State* st) {
   bool changed = changePriority((MainPanel*)st->panel, 1);
   return changed ? HTOP_REFRESH : HTOP_OK;
}
Пример #7
0
static void millisleep(unsigned long millisec) {
   struct timespec req = {
      .tv_sec = 0,
      .tv_nsec = millisec * 1000000L
   };
   while(nanosleep(&req,&req)==-1) {
      continue;
   }
}

int main(int argc, char** argv) {

   int delay = -1;
   bool userOnly = false;
   uid_t userId = 0;
   int usecolors = 1;
   char *argCopy;
   char *pid;
   Hashtable *pidWhiteList = NULL;

   int opt, opti=0;
   static struct option long_opts[] =
   {
      {"help",     no_argument,         0, 'h'},
      {"version",  no_argument,         0, 'v'},
      {"delay",    required_argument,   0, 'd'},
      {"sort-key", required_argument,   0, 's'},
      {"user",     required_argument,   0, 'u'},
      {"no-color", no_argument,         0, 'C'},
      {"no-colour",no_argument,         0, 'C'},
      {"pid",      required_argument,   0, 'p'},
      {0,0,0,0}
   };
   int sortKey = 0;

   char *lc_ctype = getenv("LC_CTYPE");
   if(lc_ctype != NULL)
      setlocale(LC_CTYPE, lc_ctype);
   else if ((lc_ctype = getenv("LC_ALL")))
      setlocale(LC_CTYPE, lc_ctype);
   else
      setlocale(LC_CTYPE, "");

   /* Parse arguments */
   while ((opt = getopt_long(argc, argv, "hvCs:d:u:p:", long_opts, &opti))) {
      if (opt == EOF) break;
      switch (opt) {
         case 'h':
            printHelpFlag();
            break;
         case 'v':
            printVersionFlag();
            break;
         case 's':
            if (strcmp(optarg, "help") == 0) {
               for (int j = 1; j < LAST_PROCESSFIELD; j++)
                  printf ("%s\n", Process_fieldNames[j]);
               exit(0);
            }

            sortKey = ColumnsPanel_fieldNameToIndex(optarg);
            if (sortKey == -1) {
               fprintf(stderr, "Error: invalid column \"%s\".\n", optarg);
               exit(1);
            }
            break;
         case 'd':
            if (sscanf(optarg, "%16d", &delay) == 1) {
               if (delay < 1) delay = 1;
               if (delay > 100) delay = 100;
            } else {
               fprintf(stderr, "Error: invalid delay value \"%s\".\n", optarg);
               exit(1);
            }
            break;
         case 'u':
            if (!setUserOnly(optarg, &userOnly, &userId)) {
               fprintf(stderr, "Error: invalid user \"%s\".\n", optarg);
               exit(1);
            }
            break;
         case 'C':
            usecolors=0;
            break;
        case 'p': {
            argCopy = strdup(optarg);
            char* saveptr;
            pid = strtok_r(argCopy, ",", &saveptr);

            if( !pidWhiteList ) {
               pidWhiteList = Hashtable_new(8, false);
            }

            while( pid ) {
                unsigned int num_pid = atoi(pid);
                Hashtable_put(pidWhiteList, num_pid, (void *) 1);
                pid = strtok_r(NULL, ",", &saveptr);
            }
            free(argCopy);

            break;
         }
         default:
            exit(1);
      }
   }


   if (access(PROCDIR, R_OK) != 0) {
      fprintf(stderr, "Error: could not read procfs (compiled to look in %s).\n", PROCDIR);
      exit(1);
   }

   int quit = 0;
   int refreshTimeout = 0;
   int resetRefreshTimeout = 5;
   bool doRefresh = true;
   bool doRecalculate = false;
   Settings* settings;
   
   ProcessList* pl = NULL;
   UsersTable* ut = UsersTable_new();

#ifdef HAVE_LIBNCURSESW
   char *locale = setlocale(LC_ALL, NULL);
   if (locale == NULL || locale[0] == '\0')
      locale = setlocale(LC_CTYPE, NULL);
   if (locale != NULL &&
       (strstr(locale, "UTF-8") ||
        strstr(locale, "utf-8") ||
        strstr(locale, "UTF8")  ||
        strstr(locale, "utf8")))
      CRT_utf8 = true;
   else
      CRT_utf8 = false;
#endif

   pl = ProcessList_new(ut, pidWhiteList);
   Process_getMaxPid();
   
   Header* header = Header_new(pl);
   settings = Settings_new(pl, header, pl->cpuCount);
   int headerHeight = Header_calculateHeight(header);

   // FIXME: move delay code to settings
   if (delay != -1)
      settings->delay = delay;
   if (!usecolors) 
      settings->colorScheme = COLORSCHEME_MONOCHROME;

   CRT_init(settings->delay, settings->colorScheme);

   Panel* panel = Panel_new(0, headerHeight, COLS, LINES - headerHeight - 2, false, &Process_class);
   ProcessList_setPanel(pl, panel);
   
   FunctionBar* defaultBar = FunctionBar_new(defaultFunctions, NULL, NULL);
   setTreeView(pl, defaultBar, pl->treeView);
   
   if (sortKey > 0) {
      pl->sortKey = sortKey;
      setTreeView(pl, defaultBar, false);
      pl->direction = 1;
   }
   ProcessList_printHeader(pl, Panel_getHeader(panel));

   IncSet* inc = IncSet_new(defaultBar);

   ProcessList_scan(pl);
   millisleep(75);
   
   FunctionBar_draw(defaultBar, NULL);
   
   int acc = 0;
   bool follow = false;
 
   struct timeval tv;
   double oldTime = 0.0;

   int ch = ERR;
   int closeTimeout = 0;

   bool idle = false;
   
   bool collapsed = false;
   
   while (!quit) {
      gettimeofday(&tv, NULL);
      double newTime = ((double)tv.tv_sec * 10) + ((double)tv.tv_usec / 100000);
      bool recalculate = (newTime - oldTime > settings->delay);
      int following = follow ? selectedPid(panel) : -1;
      if (recalculate) {
         Header_draw(header);
         oldTime = newTime;
      }
      if (doRefresh) {
         if (recalculate || doRecalculate) {
            ProcessList_scan(pl);
            doRecalculate = false;
         }
         if (refreshTimeout == 0 || pl->treeView) {
            ProcessList_sort(pl);
            refreshTimeout = 1;
         }
         ProcessList_rebuildPanel(pl, true, following, userOnly, userId, IncSet_filter(inc));
         idle = false;
      }
      doRefresh = true;
      
      if (pl->treeView) {
         Process* p = (Process*) Panel_getSelected(panel);
         if (p) {
            if (!p->showChildren && !collapsed) {
               FunctionBar_setLabel(defaultBar, KEY_F(6), "Expand");
               FunctionBar_draw(defaultBar, NULL);
            } else if (p->showChildren && collapsed) {
               FunctionBar_setLabel(defaultBar, KEY_F(6), "Collap");
               FunctionBar_draw(defaultBar, NULL);
            }
            collapsed = !p->showChildren;
         }
      }

      if (!idle) {
         Panel_draw(panel, true);
      }
      
      int prev = ch;
      if (inc->active)
         move(LINES-1, CRT_cursorX);
      ch = getch();

      if (ch == ERR) {
         if (!inc->active)
            refreshTimeout--;
         if (prev == ch && !recalculate) {
            closeTimeout++;
            if (closeTimeout == 100) {
               break;
            }
         } else
            closeTimeout = 0;
         idle = true;
         continue;
      }
      idle = false;

      if (ch == KEY_MOUSE) {
         MEVENT mevent;
         int ok = getmouse(&mevent);
         if (ok == OK) {
            if (mevent.bstate & BUTTON1_CLICKED) {
               if (mevent.y == panel->y) {
                  int x = panel->scrollH + mevent.x + 1;
                  ProcessField field = ProcessList_keyAt(pl, x);
                  if (field == pl->sortKey) {
                     ProcessList_invertSortOrder(pl);
                     setTreeView(pl, defaultBar, false);
                  } else {
                     setSortKey(pl, defaultBar, field, panel, settings);
                  }
                  refreshTimeout = 0;
                  continue;
               } else if (mevent.y >= panel->y + 1 && mevent.y < LINES - 1) {
                  Panel_setSelected(panel, mevent.y - panel->y + panel->scrollV - 1);
                  doRefresh = false;
                  refreshTimeout = resetRefreshTimeout;
                  follow = true;
                  continue;
               } if (mevent.y == LINES - 1) {
                  ch = FunctionBar_synthesizeEvent(inc->bar, mevent.x);
               }
            } else if (mevent.bstate & BUTTON4_CLICKED) {
               ch = KEY_UP;
            #if NCURSES_MOUSE_VERSION > 1
            } else if (mevent.bstate & BUTTON5_CLICKED) {
               ch = KEY_DOWN;
            #endif
            }
         }
      }

      if (inc->active) {
         doRefresh = IncSet_handleKey(inc, ch, panel, getMainPanelValue, NULL);
         continue;
      }
      
      if (isdigit((char)ch)) {
         if (Panel_size(panel) == 0) continue;
         pid_t pid = ch-48 + acc;
         for (int i = 0; i < ProcessList_size(pl); i++) {
            Panel_setSelected(panel, i);
            Process* p = (Process*) Panel_getSelected(panel);
            if (p && p->pid == pid) {
               break;
            }
         }
         acc = pid * 10;
         if (acc > 10000000)
            acc = 0;
         continue;
      } else {
         acc = 0;
      }

      switch (ch) {
      case KEY_RESIZE:
         Panel_resize(panel, COLS, LINES-headerHeight-1);
         IncSet_drawBar(inc);
         break;
      case 'M':
      {
         refreshTimeout = 0;
         setSortKey(pl, defaultBar, PERCENT_MEM, panel, settings);
         break;
      }
      case 'T':
      {
         refreshTimeout = 0;
         setSortKey(pl, defaultBar, TIME, panel, settings);
         break;
      }
      case 'c':
      {
         Process* p = (Process*) Panel_getSelected(panel);
         if (!p) break;
         tagAllChildren(panel, p);
         break;
      }
      case 'U':
      {
         for (int i = 0; i < Panel_size(panel); i++) {
            Process* p = (Process*) Panel_get(panel, i);
            p->tag = false;
         }
         doRefresh = true;
         break;
      }
      case 'P':
      {
         refreshTimeout = 0;
         setSortKey(pl, defaultBar, PERCENT_CPU, panel, settings);
         break;
      }
      case KEY_F(1):
      case 'h':
      case '?':
      {
         showHelp(pl);
         FunctionBar_draw(defaultBar, NULL);
         refreshTimeout = 0;
         break;
      }
      case '\014': // Ctrl+L
      {
         clear();
         FunctionBar_draw(defaultBar, NULL);
         refreshTimeout = 0;
         break;
      }
      case ' ':
      {
         Process* p = (Process*) Panel_getSelected(panel);
         if (!p) break;
         Process_toggleTag(p);
         Panel_onKey(panel, KEY_DOWN);
         break;
      }
      case 's':
      {
         Process* p = (Process*) Panel_getSelected(panel);
         if (!p) break;
         TraceScreen* ts = TraceScreen_new(p);
         TraceScreen_run(ts);
         TraceScreen_delete(ts);
         clear();
         FunctionBar_draw(defaultBar, NULL);
         refreshTimeout = 0;
         CRT_enableDelay();
         break;
      }
      case 'l':
      {
         Process* p = (Process*) Panel_getSelected(panel);
         if (!p) break;
         OpenFilesScreen* ts = OpenFilesScreen_new(p);
         OpenFilesScreen_run(ts);
         OpenFilesScreen_delete(ts);
         clear();
         FunctionBar_draw(defaultBar, NULL);
         refreshTimeout = 0;
         CRT_enableDelay();
         break;
      }
      case 'S':
      case 'C':
      case KEY_F(2):
      {
         Setup_run(settings, header);
         // TODO: shouldn't need this, colors should be dynamic
         ProcessList_printHeader(pl, Panel_getHeader(panel));
         headerHeight = Header_calculateHeight(header);
         Panel_move(panel, 0, headerHeight);
         Panel_resize(panel, COLS, LINES-headerHeight-1);
         FunctionBar_draw(defaultBar, NULL);
         refreshTimeout = 0;
         break;
      }
      case 'F':
      {
         follow = true;
         continue;
      }
      case 'u':
      {
         Panel* usersPanel = Panel_new(0, 0, 0, 0, true, Class(ListItem));
         Panel_setHeader(usersPanel, "Show processes of:");
         UsersTable_foreach(ut, addUserToVector, usersPanel);
         Vector_insertionSort(usersPanel->items);
         ListItem* allUsers = ListItem_new("All users", -1);
         Panel_insert(usersPanel, 0, (Object*) allUsers);
         const char* fuFunctions[] = {"Show    ", "Cancel ", NULL};
         ListItem* picked = (ListItem*) pickFromVector(panel, usersPanel, 20, headerHeight, fuFunctions, defaultBar, header);
         if (picked) {
            if (picked == allUsers) {
               userOnly = false;
            } else {
               setUserOnly(ListItem_getRef(picked), &userOnly, &userId);
            }
         }
         Panel_delete((Object*)usersPanel);
         break;
      }
      case '+':
      case '=':
      case '-':
      {
         if (expandCollapse(panel)) {
            doRecalculate = true;         
            refreshTimeout = 0;
         }
         break;
      }
      case KEY_F(9):
      case 'k':
      {
         Panel* signalsPanel = (Panel*) SignalsPanel_new();
         const char* fuFunctions[] = {"Send  ", "Cancel ", NULL};
         ListItem* sgn = (ListItem*) pickFromVector(panel, signalsPanel, 15, headerHeight, fuFunctions, defaultBar, header);
         if (sgn) {
            if (sgn->key != 0) {
               Panel_setHeader(panel, "Sending...");
               Panel_draw(panel, true);
               refresh();
               foreachProcess(panel, (ForeachProcessFn) Process_sendSignal, (size_t) sgn->key, NULL);
               napms(500);
            }
         }
         ProcessList_printHeader(pl, Panel_getHeader(panel));
         Panel_delete((Object*)signalsPanel);
         refreshTimeout = 0;
         break;
      }
#if (HAVE_LIBHWLOC || HAVE_NATIVE_AFFINITY)
      case 'a':
      {
         if (pl->cpuCount == 1)
            break;

         Process* p = (Process*) Panel_getSelected(panel);
         if (!p) break;
         Affinity* affinity = Process_getAffinity(p);
         if (!affinity) break;
         Panel* affinityPanel = AffinityPanel_new(pl, affinity);
         Affinity_delete(affinity);

         const char* fuFunctions[] = {"Set    ", "Cancel ", NULL};
         void* set = pickFromVector(panel, affinityPanel, 15, headerHeight, fuFunctions, defaultBar, header);
         if (set) {
            Affinity* affinity = AffinityPanel_getAffinity(affinityPanel);
            bool ok = foreachProcess(panel, (ForeachProcessFn) Process_setAffinity, (size_t) affinity, NULL);
            if (!ok) beep();
            Affinity_delete(affinity);
         }
         Panel_delete((Object*)affinityPanel);
         ProcessList_printHeader(pl, Panel_getHeader(panel));
         refreshTimeout = 0;
         break;
      }
#endif
      case KEY_F(10):
      case 'q':
         quit = 1;
         break;
      case '<':
      case ',':
      case '>':
      case '.':
      {
         sortBy(panel, pl, settings, headerHeight, defaultBar, header);
         refreshTimeout = 0;
         break;
      }
      case KEY_F(18):
      case KEY_F(6):
      {
         if (pl->treeView) {
            if (expandCollapse(panel)) {
               doRecalculate = true;
               refreshTimeout = 0;
            }
         } else {
            sortBy(panel, pl, settings, headerHeight, defaultBar, header);
            refreshTimeout = 0;
         }
         break;
      }
      case 'i':
      {
         Process* p = (Process*) Panel_getSelected(panel);
         if (!p) break;
         IOPriority ioprio = p->ioPriority;
         Panel* ioprioPanel = IOPriorityPanel_new(ioprio);
         const char* fuFunctions[] = {"Set    ", "Cancel ", NULL};
         void* set = pickFromVector(panel, ioprioPanel, 21, headerHeight, fuFunctions, defaultBar, header);
         if (set) {
            IOPriority ioprio = IOPriorityPanel_getIOPriority(ioprioPanel);
            bool ok = foreachProcess(panel, (ForeachProcessFn) Process_setIOPriority, (size_t) ioprio, NULL);
            if (!ok)
               beep();
         }
         Panel_delete((Object*)ioprioPanel);
         ProcessList_printHeader(pl, Panel_getHeader(panel));
         refreshTimeout = 0;
         break;
      }
      case 'I':
      {
         refreshTimeout = 0;
         settings->changed = true;
         ProcessList_invertSortOrder(pl);
         break;
      }
      case KEY_F(8):
      case '[':
      {
         doRefresh = changePriority(panel, 1);
         break;
      }
      case KEY_F(7):
      case ']':
      {
         doRefresh = changePriority(panel, -1);
         break;
      }
      case KEY_F(3):
      case '/':
         IncSet_activate(inc, INC_SEARCH);
         break;
      case KEY_F(4):
      case '\\':
         IncSet_activate(inc, INC_FILTER);
         refreshTimeout = 0;
         doRefresh = true;
         continue;
      case 't':
      case KEY_F(5):
         refreshTimeout = 0;
         collapsed = false;
         setTreeView(pl, defaultBar, !pl->treeView);
         if (pl->treeView) pl->direction = 1;
         ProcessList_printHeader(pl, Panel_getHeader(panel));
         ProcessList_expandTree(pl);
         settings->changed = true;
         if (following != -1) continue;
         break;
      case 'H':
         doRecalculate = true;
         refreshTimeout = 0;
         pl->hideUserlandThreads = !pl->hideUserlandThreads;
         pl->hideThreads = pl->hideUserlandThreads;
         settings->changed = true;
         break;
      case 'K':
         doRecalculate = true;
         refreshTimeout = 0;
         pl->hideKernelThreads = !pl->hideKernelThreads;
         settings->changed = true;
         break;
      default:
         doRefresh = false;
         refreshTimeout = resetRefreshTimeout;
         Panel_onKey(panel, ch);
         break;
      }
      follow = false;
   }
   attron(CRT_colors[RESET_COLOR]);
   mvhline(LINES-1, 0, ' ', COLS);
   attroff(CRT_colors[RESET_COLOR]);
   refresh();
   
   CRT_done();
   if (settings->changed)
      Settings_write(settings);
   Header_delete(header);
   ProcessList_delete(pl);
   IncSet_delete(inc);
   FunctionBar_delete((Object*)defaultBar);
   Panel_delete((Object*)panel);
   UsersTable_delete(ut);
   Settings_delete(settings);
   if(pidWhiteList) {
      Hashtable_delete(pidWhiteList);
   }
   return 0;
}
Пример #8
0
void deleteq (queue *q, int ind)
{
	changePriority (q, ind, INT_MIN);
	deleteMin (q);
}
Пример #9
0
void svc(SYSTEM_CALL_DATA *SystemCallData) {
	MEMORY_MAPPED_IO mmio; 
	short call_type;
	static short do_print = 10;
	INT32 Time;
	INT32 Status;
	short i;
	long* arg0=SystemCallData->Argument[0];
	long* arg1=SystemCallData->Argument[1];
	long* arg2=SystemCallData->Argument[2];
	long* arg3=SystemCallData->Argument[3];
	long* arg4=SystemCallData->Argument[4];
	long *arg5=SystemCallData->Argument[5];
	call_type = (short) SystemCallData->SystemCallNumber;
	if (do_print > 0) {
		printf("SVC handler: %s\n", call_names[call_type]);
		for (i = 0; i < SystemCallData->NumberOfArguments - 1; i++) {
			printf("Arg %d: Contents = (Decimal) %8ld,  (Hex) %8lX\n", i,
					(unsigned long) SystemCallData->Argument[i],
					(unsigned long) SystemCallData->Argument[i]);
		} 
		do_print--;
	}

	switch (call_type) {
		// Get time service call
		case SYSNUM_GET_TIME_OF_DAY:
			mmio.Mode = Z502ReturnValue;
			mmio.Field1 = mmio.Field2 = mmio.Field3 = 0;
			MEM_READ(Z502Clock, &mmio);//hardware call
			Time = mmio.Field1;
			(SystemCallData->Argument[0])=(long*)&Time;

			//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
			break;
				// get the Timer start and generate idle.
		case SYSNUM_SLEEP:

			startTimer(arg0);

			//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);

			Dispatcher();//call dispatcher	

			break;

		// create process
		case SYSNUM_CREATE_PROCESS:
			OSCreateProcess(arg0,arg1,arg2,arg3,arg4);
			//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
			break;

		// get process id
		case SYSNUM_GET_PROCESS_ID:
			getProcessID(arg0,arg1,arg2);
			//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
			break;

		// suspend process
		case SYSNUM_SUSPEND_PROCESS:
			suspendProcess(arg0, arg1);
			//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
			break;
		
		// resume the process
		case SYSNUM_RESUME_PROCESS:
			resumeProcess(arg0, arg1);
			//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
			break;
		
		// change priority;
		case SYSNUM_CHANGE_PRIORITY:
			changePriority(arg0,arg1,arg2);
			//statePrinter(call_type,arg0, arg1, arg2, arg3, arg4);
			break;

		// terminate system call
		case SYSNUM_TERMINATE_PROCESS:
			terminateSysProcess(arg0,arg1);
			break;

		case SYSNUM_SEND_MESSAGE:
			Send_message(arg0, arg1, arg2, arg3);

			break;

		case SYSNUM_RECEIVE_MESSAGE:
			ReceiveMessage(arg0, arg1, arg2, arg3, arg4, arg5);
			break;
		
		case SYSNUM_DISK_WRITE:
			DiskWrite(arg0, arg1, arg2);
			break;

		case SYSNUM_DISK_READ:
			DiskRead(arg0, arg1, arg2);
			break;

		case SYSNUM_DEFINE_SHARED_AREA:
			DefineSharedArea(arg0, arg1, arg2,arg3,arg4);
			break;

		default:
			printf( "ERROR!  call_type not recognized!\n" ); 
			printf( "Call_type is - %i\n", call_type);

	}
}                                               // End of svc
Пример #10
0
int release(int numlocks,int ldes1)
{
	struct lentry *lptr;
	struct pentry *pptr;
	int i;	

	pptr=&proctab[currpid];
	

	
	if (pptr->deleted[ldes1]==1)			//check if the locks has been deleted
	{

		pptr->deleted[ldes1]==0;
		pptr->pwaitret=OK;
		//continue;
		return (SYSERR);
	}
							//if bad lock
	if(isbadlock(ldes1) || (lptr=&lockarr[ldes1])->lstate==LFREE ||pptr->pwaitret==DELETED)
	{	pptr->pwaitret=OK;
		return (SYSERR);
	}
	if (pptr->pinh != 0)
	{
		pptr->pinh=0;
		//chprio(currpid,pptr->prioh);
	}
	


	if (lptr->lstate==READ)
	{	
		lptr->holder[currpid]=-1;
		pptr->lockdesc[ldes1]=-1;
		if (lptr->r_count>0)				//if more readers present in the waiting queue
		{
			lptr->r_count--;
			if (lptr->r_count ==0 && !isEmpty(lptr->lhead))
			{

			}
			else
			return OK;				
			
		}
				
	}	
	else							//change the holder of the process and of the locks
	{
		lptr->holder[currpid]=-1;
		pptr->lockdesc[ldes1]=-1;

	}
	

	pptr->pinh=0;						//check for the inverted priority
	for(i=0;i<50;i++)
	{
		if (pptr->lockdesc[i]==1)
		{
			changePriority(i,getlast((&lockarr[i])->ltail));
		}
	}
	pop_3(lptr->lhead,lptr->ltail,ldes1);
	//continue;	
	return OK;
}
Пример #11
0
int analyzeAndSetPriorities(int gameBoard[BOARD_SIZE][BOARD_SIZE], int priorityArray[BOARD_SIZE][BOARD_SIZE], int player, int enemy, int startingX, int startingY, int XIncrement, int YIncrement){
    int x,y;
    int cell1X, cell1Y, cell2X, cell2Y, cell3X, cell3Y;
    int cell1, cell2, cell3;
    int highestPriority = 0;

    /*                      *\
    **  Definizione celle   **
    \*                      */

    cell1X = startingX;
    cell1Y = startingY;

    cell2X = startingX + XIncrement;
    cell2Y = startingY + YIncrement;


    cell3X = startingX + (2 * XIncrement);
    cell3Y = startingY + (2 * YIncrement);

    cell1 = gameBoard[cell1X][cell1Y];
    cell2 = gameBoard[cell2X][cell2Y];
    cell3 = gameBoard[cell3X][cell3Y];

    if(isPlayerOrEnemy(cell1, player, enemy)){  //La cella 1 e' piena
        if(isPlayerOrEnemy(cell2, player, enemy)){  //La cella 2 e' piena
            if(isPlayerOrEnemy(cell3, player, enemy)){  //La cella 3 e' piena
                if(areEqual(cell1,cell2,cell3)){    //Le 3 celle appartengono allo stesso giocatore
                    if(isPlayer(cell1,player)){
                        return 5;
                    }
                    else{
                        return 6;
                    }
                }
            }
            else{   //La cella 3 e' vuota
                if(cell1 == cell2){
                    if(isPlayer(cell1,player)){ //Le due celle piene appartengono al giocatore
                        changePriority(&priorityArray[cell3X][cell3Y], PRIOR_MAX, &highestPriority);
                    }
                    else{
                        changePriority(&priorityArray[cell3X][cell3Y], PRIOR_HIGH, &highestPriority);
                    }
                }
                else{ // Le due celle piene sono uguali, mossa inutile.
                    changePriority(&priorityArray[cell3X][cell3Y], PRIOR_LOW, &highestPriority);
                }
            }
        }
        else{ //La cella 2 e' vuota -- La cella 1 e' piena
            if(isPlayerOrEnemy(cell3,player,enemy)){ //La cella 3 e' piena
                if(cell1 == cell3){
                    if(isPlayer(cell1,player)){
                        changePriority(&priorityArray[cell2X][cell2Y], PRIOR_MAX, &highestPriority);
                    }
                    else{
                        changePriority(&priorityArray[cell2X][cell2Y], PRIOR_HIGH, &highestPriority);
                    }
                }
                else{ //Le celle piene sono diverse fra loro, mossa inutile
                    changePriority(&priorityArray[cell2X][cell2Y], PRIOR_LOW, &highestPriority);
                }
            }
            else{ //Le celle 2 e 3 aono vuote -- La cella 1 e' piena
                if(isPlayer(cell1,player)){
                    changePriority(&priorityArray[cell2X][cell2Y], PRIOR_MED, &highestPriority);
                    changePriority(&priorityArray[cell3X][cell3Y], PRIOR_MED, &highestPriority);
                }
                else{
                    changePriority(&priorityArray[cell2X][cell2Y], PRIOR_LOW, &highestPriority);
                    changePriority(&priorityArray[cell3X][cell3Y], PRIOR_LOW, &highestPriority);
                }
            }
        }
    }
    else{ //La cella 1 e' vuota
        if(isPlayerOrEnemy(cell2,player,enemy)){ //La cella 2 e' piena
            if(isPlayerOrEnemy(cell3,player,enemy)){ //La cella 3 e' piena
                if(cell2 == cell3){
                    if(isPlayer(cell2,player)){
                        changePriority(&priorityArray[cell1X][cell1Y], PRIOR_MAX, &highestPriority);
                    }
                    else{
                        changePriority(&priorityArray[cell1X][cell1Y], PRIOR_HIGH, &highestPriority);
                    }
                }
                else{ //Le celle piene sono diverse, mossa inutile.
                    changePriority(&priorityArray[cell1X][cell1Y], PRIOR_LOW, &highestPriority);
                }
            }
            else{ //Celle 1 e 3 vuote -- Cella 2 piena
                if(isPlayer(cell2,player)){
                    changePriority(&priorityArray[cell1X][cell1Y], PRIOR_MED, &highestPriority);
                    changePriority(&priorityArray[cell3X][cell3Y], PRIOR_MED, &highestPriority);
                }
                else{
                    changePriority(&priorityArray[cell1X][cell1Y], PRIOR_LOW, &highestPriority);
                    changePriority(&priorityArray[cell3X][cell3Y], PRIOR_LOW, &highestPriority);
                }
            }
        }
        else{ //Celle 1 e 2 vuote
            if(isPlayerOrEnemy(cell3,player,enemy)){ //Cella 3 piena
                if(isPlayer(cell3,player)){
                    changePriority(&priorityArray[cell2X][cell2Y], PRIOR_MED, &highestPriority);
                    changePriority(&priorityArray[cell1X][cell1Y], PRIOR_MED, &highestPriority);
                }
                else{
                    changePriority(&priorityArray[cell2X][cell2Y], PRIOR_LOW, &highestPriority);
                    changePriority(&priorityArray[cell1X][cell1Y], PRIOR_LOW, &highestPriority);
                }
            }
            else{ //Tutte le celle sono vuote
                changePriority(&priorityArray[cell1X][cell1Y], PRIOR_LOW, &highestPriority);
                changePriority(&priorityArray[cell2X][cell2Y], PRIOR_LOW, &highestPriority);
                changePriority(&priorityArray[cell3X][cell3Y], PRIOR_LOW, &highestPriority);
            }
        }
    }

    return highestPriority;
}