cafe-grader-judge-scripts Commit

cafe-grader-judge-scripts

Commit `r131:d5c4e1d8daa2` public

parent | child

Description:

updated box for windows to prevent error modal dialog

Commit status:

[Not Reviewed]

References:

default

Diff options:

| | | |

Comments:

0 Commit comments 0 Inline Comments

Unresolved TODOs:

There are no unresolved TODOs

Add another comment

r131:d5c4e1d8daa2 - Tue, 04 May 2010 15:56:59 - 1 file changed: 3 inserted, 0 deleted

std-script/box-win/execute.cpp ¶ +3

                 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION |
               			 PROCESS_VM_READ,
               			 FALSE,processID);
                 if(hProcess == NULL)
                   return;
                 if(GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) {
                   printf("\tPageFaultCount: %d\n",pmc.PageFaultCount);
                   printf("\tPeakWorkingSetSize: %d\n",
               	   pmc.PeakWorkingSetSize);
                   printf("\tWorkingSetSize: %d\n",pmc.WorkingSetSize);
                   printf("\tQuotaPeakPagedPoolUsage: %d\n",
               	   pmc.QuotaPeakPagedPoolUsage);
                   printf("\tQuotaPagedPoolUsage: %d\n",
               	   pmc.QuotaPagedPoolUsage);
                   printf("\tQuotaPeakNonPagedPoolUsage: %d\n",
               	   pmc.QuotaPeakNonPagedPoolUsage);
                   printf("\tQuotaNonPagedPoolUsage: %d\n",
               	   pmc.QuotaNonPagedPoolUsage);
                   printf("\tPagefileUsage: %d\n",pmc.PagefileUsage);
                   printf("\tPeakPagefileUsage: %d\n",
               	   pmc.PeakPagefileUsage);
                 }
                 CloseHandle( hProcess );
               }
               int check_memory_usage(DWORD pid, int max_mem, int *actual_usage) {
                 // modified from http://msdn.microsoft.com/en-us/library/ms682050(VS.85).aspx
                 //PrintMemoryInfo(pid);
                 HANDLE hProcess;
                 PROCESS_MEMORY_COUNTERS pmc;
                 if((max_mem==0) || (pid==0))
                   return 1;
                 if(pid == get_ntvdm_pid()) {
                   fprintf(stderr,"ntvdm: ignored\n");
                   return 1;
                 }
                 hProcess = OpenProcess(PROCESS_QUERY_INFORMATION |
               			 PROCESS_VM_READ,
               			 FALSE, pid);
                 if(hProcess == NULL)
                   return 1;
                 int max_mem_usage = 0;
                 if(GetProcessMemoryInfo(hProcess, &pmc, sizeof(pmc))) {
                   max_mem_usage = pmc.PeakWorkingSetSize;
                   if(pmc.PeakPagefileUsage > max_mem_usage)
                     max_mem_usage = pmc.PeakPagefileUsage;
                 }
                 CloseHandle(hProcess);
                 if(actual_usage != NULL)
                   (*actual_usage) = max_mem_usage;
                 return (max_mem_usage <= max_mem);
               }
               void report_stat(double time_used, int memory_used)
               {
                 fprintf(stderr,"%.4lfr%.4lfu%.4lfs%dm\n",
               	  time_used,
               	  time_used, (double)0,
               	  memory_used);
               }
               double get_process_time_usage(HANDLE hProcess)
               {
                 FILETIME creation_time;
                 FILETIME exit_time;
                 FILETIME kernel_time;
                 FILETIME user_time;
                 GetProcessTimes(hProcess,
               		  &creation_time,
               		  &exit_time,
               		  &kernel_time,
               		  &user_time);
                 SYSTEMTIME sys_kernel_time;
                 SYSTEMTIME sys_user_time;
                 FileTimeToSystemTime(&kernel_time, &sys_kernel_time);
                 FileTimeToSystemTime(&user_time, &sys_user_time);
                 double time_used =
                   ((sys_kernel_time.wSecond + sys_kernel_time.wMilliseconds/1000.0) +
                    (sys_user_time.wSecond + sys_user_time.wMilliseconds/1000.0));
                 return time_used;
               }
               int execute(char *exname, char *inname, char *outname, double t, int max_mem)
               {
                 STARTUPINFO si;
                 PROCESS_INFORMATION pi;
                 int ifsuccess = EXE_RESULT_OK;
+            +   SetErrorMode(SEM_FAILCRITICALERRORS);
+            +   SetErrorMode(SEM_NOGPFAULTERRORBOX);
+            +
                 ZeroMemory(&si, sizeof(si));
                 si.cb = sizeof(si);
                 ZeroMemory(&pi, sizeof(pi));
                 setstartupinfo(&si, inname, outname);
                 if(!CreateProcess( NULL,  // No module name (use command line).
               		     TEXT(exname), // Command line.
               		     NULL,  // Process handle not inheritable.
               		     NULL,  // Thread handle not inheritable.
               		     TRUE,  // Set handle inheritance to FALSE.
 ,     // No creation flags.
               		     NULL,  // Use parent's environment block.
               		     NULL,  // Use parent's starting directory.
               		     &si,   // Pointer to STARTUPINFO structure.
               		     &pi))  // Pointer to PROCESS_INFORMATION structure.
                   {
                     //printf( "CreateProcess failed (%d).\n", GetLastError() );
                     fprintf(stderr, "Process creation error.\n");
                     report_stat(0,0);
                     return EXE_RESULT_ERROR;
                   }
                 //fprintf(stderr,"Process ID: %ld\n",pi.dwProcessId);
                 //fprintf(stderr,"time limit = %d\n",t);
                 // checking memory usage
                 // wait 0.1 sec before checking mem usage
                 SetProcessWorkingSetSize(pi.hProcess,
 ,
               			   max_mem);
                 int actual_memory_usage = 0;
                 Sleep(INITIAL_WAIT_FOR_MEM_CHECK);
                 if(!check_memory_usage(pi.dwProcessId,max_mem,&actual_memory_usage)) {
                   // using too much memory
                   fprintf(stderr,"Memory limit exceeded.\n");
                   //PrintMemoryInfo(pi.dwProcessId);
                   ifsuccess = EXE_RESULT_MEMORY;
                 }
                 //printf("PID: %d\n", pi.dwProcessId);
                 if(ifsuccess != EXE_RESULT_MEMORY) {
                   int based_time = (int)(t*1000) + 1 - INITIAL_WAIT_FOR_MEM_CHECK;
                   bool major_timed_out = (WaitForSingleObject(pi.hProcess,
               						based_time)==WAIT_TIMEOUT);
                   if(major_timed_out) {
                     // wait some more for user time.
                     double time_used = get_process_time_usage(pi.hProcess);
                     while(time_used <= t) {
               	int iter_time = 100;
               	if(t - time_used < 200)
               	  iter_time = 20;
               	bool iter_timed_out = (WaitForSingleObject(pi.hProcess,
               						   iter_time)==WAIT_TIMEOUT);
               	if(!iter_timed_out)
               	  break;
               	time_used = get_process_time_usage(pi.hProcess);
               	//printf("%lf\n",time_used);
                     }
                     ifsuccess = EXE_RESULT_TIMEOUT;
                   }
                 }
                 if((ifsuccess == EXE_RESULT_MEMORY) || (ifsuccess == EXE_RESULT_TIMEOUT)) {
                   // Kill process, because (1) it used too much memory, or (2) time limit
                   HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pi.dwProcessId);
                   if(ifsuccess != EXE_RESULT_MEMORY)
                     fprintf(stderr,"Time limit exceeded.\n");
                   if(hProcess != NULL) {
                     fprintf(stderr,"killing pid: %ld\n",pi.dwProcessId);
                     TerminateProcess(hProcess, 0);
                     wait_dialog();
                   } else {
                     DWORD dwNtvdmId = get_ntvdm_pid();
                     fprintf(stderr,"killing (ntvdm) pid: %ld\n",dwNtvdmId);
                     if(dwNtvdmId!=0) {
               	hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwNtvdmId);
               	TerminateProcess(hProcess, 0);
                     } else {
                       fprintf(stderr,"killing process error\n");
                     }
                     if(get_ntvdm_pid()!=0) {
               	fprintf(stderr,"killing error, ntvdm.exe still remains;");
               	fprintf(stderr,"please MANUALLY kill it.");
               	fflush(stderr);
               	do {
               	  Sleep(1000);
               	} while(get_ntvdm_pid()!=0);
               	fprintf(stderr,"... done\n");
               	wait_dialog();
                     }

Write
Preview

You need to be logged in to leave comments. Login now

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository permissions settings

Sign in to your account

Author

r131:d5c4e1d8daa2 - Tue, 04 May 2010 15:56:59 - 1 file changed: 3 inserted, 0 deleted

Sign in to your account

Commit r131:d5c4e1d8daa2 public

Author

r131:d5c4e1d8daa2 - Tue, 04 May 2010 15:56:59 - 1 file changed: 3 inserted, 0 deleted

Commit `r131:d5c4e1d8daa2` public