Processes and Threads M5 Test

Processes and Threads M5 Test

1. Which of the “C” programming language standards offers built-in thread implementation?

   • C99
   • C89
   • C11
   • ANSI C

2. Which of the following main() function’s headers is valid?

   • int main(int argc, char *argv[], char env)
   • int main(int argc, char * argv[], char **env)
   • int main(int argc, char *argv[], char *env)
   • int main(int argc, char * argv[], char ***env)

3. Assuming that the code was compiled and run in a Unix/Linux environment, what is its expected output?

   #include <stdio.h>
   #include <unistd.h>
   int x = 0;
   int main(void) {
       if(fork()){
                  printf("%d", ++x);
               return 0;
        }else{
                  printf("%d", ++x);
               return 0;
       }
   }

   • 12
   • 21
   • 11
   • 22

4. To determine if the system shell is available or not, you would use the following invocation:

   • if(system("shell")) {...}
   • if(system(""){...}
   • if(system("NULL")) {...}
   • if(system(NULL)){...}

5. A variant of the exec() function, designed to pass a copy of the environment to a new process as well as use PATH to find the executable and accepting argument placed in an array, is named:

   •  execlp
   • execl
   • execlpe
   • execvpe

6. The WINAPI specifier means that the function:

   • is a static function
   • is not accessible from the outside
   • is an obsolete implementation of a standard Windows service
   • uses the standard MS Windows calling conversion

7. In an MS Windows environment, if the main thread wants to wait for all the other threads to complete, it:

   • may use the WaitForMultipleObjects() function
   • must use a number of subsequent invocations of the WaitForSingleObject() function
   • uses the Sleep() function
   • spends some time in an empty delay loop

8. What is the possible result of the following invocation?

   #include <stdlib.h>
   int main(int argc, char * argv[]){
       system(argv[0]);
       return 0;
   }

   • a compiler error
   • a stack overflow error 
   • an OS shell error
   • an infinite loop of launches

9. The term “obtain a mutex”:

   • means the same as “lock a mutex” in different OS environments
   • is not uses in any OS environment
   • means the same as “release a mutex” in different OS environments
   • means the same as “close a mutex” in different OS environments

10. Assuming that the following snippet is executed in an MS Windows environment, its effect is:

    putenv("VAR=");

    • to printf the VAR’s value to stdout
    • to remove the VAR from the environment 
    • nothing 
    • to set the VAR’s value to an empty string

11. The pid_t type is:

    • an unsigned int
    • a pointer to  a void
    • an int
    • a string

12. In the MS Windows threads, a single thread is represented as a value of type:

    • HANDLE
    • thred_t
    • thrd_t
    • msthread_t

13. In the MS Windows threads, a single thread is represented as a value of type:

    • HANDLE
    • thred_t
    • thrd_t
    • msthread_t

14. A thread, in the Pthread sense, is a function of type:

    • void thread(void * data);
    • int thread(void * data);
    • void * thread(void);
    • void * thread(void *data);

15. To determine its ID, a thread running in an MS Windows environment uses:

    • its own handle
    • the GetCurrentThreadId() function
    • its own address
    • its own name

16. After successfully invocation, the fork() function:

    • returns the child’s PID in the parent and the parent’s PID in the child 
    • return 0 in the child and the child’s PIS in the parent 
    • return 0 in both child and parent 
    • return 0 in the parent and the parent’s PID in the child

17. The MS Windows’ HANDLE data type:

    • is a structure containing a PID
    • is a string with a process name and plays a different role than a PID
    • is the same as a Unix/Linux PID
    • is a unique resource identifier and plays a different role than a PID

18. In an MS Windows environment, the native Unix/Linux functions named wait() and waitpid():

    • are replaced by the Wait() and WaitPid() functions
    • may be substituted by the WaitForSingleObject() function
    • are not needed due to the different processes’ serving philosophies
    • have the same name and purpose

19. Assuming that the code was compiled and run in a Unix/Linux environment, what is its expected output?

    #include <stdio.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/wait.h>
    
    int main(void) {
        printf("%d", fork() ==0);
        wait(NULL);
          return 0;
    }

    • 1 or 0
    • always 00
    • 10 ​or 01
    • always 11

20. The third main() function parameter is:

    • a NULL -terminated array of pointer to environment variables
    • a pointer to an array containing argc pointer to environment variables
    • a pointer to the first environment variable
    • a pointer to a NULL -terminated array of pointers to environment variable