OS First Test Review

C is based on the design of Java.

C is a design ancestor of C++ and Java.

All programming languages use the same
style of statements.

Both C and Java share Eiffel as a common design ancestor.

None of the above

bool

string

int

char

None of the above

Any non-zero value represents false.

Only the zero value represents false.

Only one value represents true.

Any non-zero value represents true.

None of the above

Perform full boolean evaluation.

Are undefined.

Are synonyms for "&&" and "||".

Perform the bitwise-and and bitwise-or functions.

None of the above

Logical negation (e.g., turn "true" into "false").

Numeric negation (e.g., turn "-3" into "3").

Numeric inversion (e.g., turn "5" into "1/5").

Array reversal (reversing the items within an array).

None of the above

works exactly like assignment in Java.

cannot be used in boolean expressions.

cannot be used in arithmetic expressio

returns the value assigned as its value.

None of the above

+ and ++

= and ==

& and &&

| and ||

None of the above

"array[12]" the value of 3

"array[13]" the value of 3

"array[12]" the value of 4

"array[13]" the value of 4

None of the above

is not allowed.

assigns "array[12]" the value of 5

assigns "array[14]" the value of 5

assigns "x" the value of 7

None of the above

scanf

getc

printf

fprintf

None of the above

scanf

getc

printf

fprintf

None of the above

scanf

getc

printf

fprintf

None of the above

void main(char* argv[])

int main(string argv[])

void main(int argc, string argv[])

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

None of the above

whether or not the program terminated normally.

nothing, this is a holdover from early Unix that is no longer used.

how long (in milliseconds) the program took to complete.

the error a program experienced if there was a problem.

None of the above

an implementation given as part of the declaration.

only primitive types given as formal parameters.

a non-empty set of formal parameters.

a non-void return type.

None of the above

must be given inside of a class definition.

must appear within the source code file in
which they are used.

can be nested within another function's implementation/body.

must be given in a separate file
(a ".h" file) from their implementation.

None of the above

cannot be given within another function's implementation/body.

begin with the "function" reserved keyword, if given separate from the
function declaration.

must always be given at the same time the
function is declared.

appear within curly braces (i.e., { }) directly after the function
signature.

None of the above

reserves space for the variable apart from the run-time stack.

allows the variable to be accessed outside of the function implementation.

ensures that only one version of the variable exists, so that recursive
calls to the function share the exact same variable storage.

is optional as all variables within function
implementations are treated as "static" by default.

None of the above

may only appear within a function implementation.

can be accessed outside the scope of the function in which it is declared.

cannot change their values (i.e., they're constants).

have space for their values reserved outside of the run-time stack.

None of the above

".c" files must contain only function
implementations.

".h" files should contain declarations used by multiple ".c" files.

the "#include" directives allow ".c" files to use the declarations in the
named ".h" file.

variables should never be delcared in a
".h" file.

None of the above

used to declare variables without setting
aside storage space.

implicit for all function declarations.

used for variables declared within a function so that they can be accessed
outside of the function.

have space for their values reserved outside of the run-time stack.

None of the above

-1

0

1

the value indicated when they are declared.

None of the above

only needs to be checked at compile time to ensure
that it's within range.

is always checked at
run time to ensure that it's within range.

never needs to be checked as it is
always within range.

is not checked since it doesn't have to
be within its range.

None of the above

string value needs to be null terminated.

array must be exactly as long as the
desired string.

array should be at least one char longer than the desired string.

programer must use another variable to
keep track of the length of the string.

None of the above

an error may or may not occur as a result of accessing the array element.

an error always occurs and the program
stops execution.

there may or may not be accessible storage associated with that array
location.

there is always accessible storage
associated with that array location.

None of the above

starting index of the array.

size of the array.

corresponding "#define" declaration for the array size.

type of the array elements.

None of the above

grow dynamically as more items are added (similar to
ArrayLists in Java).

always have an associated length that can
be queried to determine the number of items in the array.

are polymorphic, meaning that any mix of items can be stored in the same
array.

are really just pointers to their item type
(e.g., "int x[]" and "int *x" are the same).

None of the above

type of values that can be assigned to a variable.

forward declaration of a function.

declaration of a "struct"ure.

address of the memory location holding a desired value.

None of the above

only for declarations of arrays.

by giving an asterisk (*) before the variable name declaration.

by giving an ampersand (&) before the variable name declaration.

for all formal parameters of functions.

None of the above

is undefined.

assigns "y" the value of "x".

makes "y" an alias for "x" so that any value assigned to one is
automatically assigned to the other.

assigns "y" the memory address where the value for "x" is located.

None of the above

reserves 10 contiguous bytes (characters) of storage for "name".

is equivalent to the declaration "string name;".

declares "name" as a pointer to the reserved storage.

declares each element of the array "name" as a pointer to a "char".

None of the above

char &var;

char var[10];

char var[];

char &var[];

None of the above

with the length kept separately so that the size of the string is known
(e.g., when printing).

that are terminated by a null value to denote their end.

and can be referenced via a "char"acter pointer (e.g., "char *").

which are immutable, so that the value cannot be changed (only copied).

None of the above

converts a variable into a pointer, so that "&y" makes "y" a pointer to an
"int" when "y" was declared via "int y;".

is only used when passing parameters.

returns the memory address of any expression it is applied to
(e.g., "&(2*x + 3)").

returns the memory address of the variable it is applied to (e.g., "&x").

None of the above

makes "x" point to the next address in memory (following "y") that can hold
an "int" value.

is undefined and causes a compilation error.

is defined but causes a run-time error.

increases the value of "y" by 1.

None of the above

multiple data items.

data of the same type.

data of different types.

None of the above

a new type name that can be used in declaring variables (e.g.,
"person bob;").

a named structure form that can be referred to by "struct" followed by the
structure name (e.g., "struct person").

a recursive structure so that linked structures (e.g., lists, graphs) can
be coded.

a non-recursive structure since recursive structures
must be declared as types instead
of "struct"s.

None of the above

"struct NAME", where "NAME" is the name given the "struct" and the pointer
type is inferred.

"struct NAME *", where "NAME" is the name given the "struct".

"struct" where the current structure and pointer type are
inferred.

"struct *" where the current structure name is inferred.

None of the above

"typedef NAME = TYPE_DESCRIPTION;"

"typedef TYPE_DESCRIPTION NAME;"

"typedef NAME TYPE_DESCRIPTION;"

"NAME = typedef TYPE_DESCRIPTION;"

None of the above

"struct bob { ... };"

"typedef struct person { ... } bob;"

"typedef struct bob bob;"

"typedef person bob;"

None of the above

"struct person { ... };"

"typedef struct { ... } person;"

"typedef struct person bob;"

"typedef person bob;"

None of the above

"nodeType" is a type equivalent to "struct node".

"nodeType" is a type equivalent to the type of the "next"
field.

"nodeType" is not a type,
but really a variable of type "struct node".

"nodeType" is not a type,
but really a variable of type pointer to a "struct node".

None of the above

getmem

new

malloc

heap_request

None of the above

delete

return

free

putmem

None of the above

getsize

sizeof

sizeOfType

typeSize

None of the above

int x = new int();

int *x = (int) getmem(int);

int x = malloc(typeSize(int));

int *x = (int*) malloc(sizeof(int));

None of the above

a clean and simple model of the computer.

manages the computer's resources.

support for the creation and use of user programs.

an abstract view of the computer, independent of the specific hardware.

None of the above

System programs

Adventure games.

Application programs

CAPTCHAs (Completely Automated Public Turing test to tell
Computers and Humans Apart).

None of the above

Machine language

Command interpreter (shell)

Physical devices

Microcode

None of the above

implements the editors, compilers, and interpreters used to
create other programs.

provides the command line interpreter (e.g., shell) for users.

comes pre-loaded on purchased computer hardware.

runs in supervisor (or kernel) mode.

None of the above

enables Windows and Unix to run at the same time.

hides the details of lower level facilities (e.g., writing data to disk).

operates exactly the way a Turing machine does.

provides the implementations for data abstractions (e.g., stack,
queue) leveraged by user programs.

None of the above

coordinates the sharing of parts of the computer by different programs.

enables different programs to share the computer hardware.

determines when more memory or disk should be purchased.

ensures that the computer hardware is utilized with optimal
efficiency regarding every user's needs.

None of the above

packet switched.

bus

circuit switched.

fully connected backplane.

None of the above

control bus.

address bus

data bus.

memory bus.

None of the above

only a single pair of components to communicate at a time.

one or two different pairs of components to communicate simultaneously.

up to three different components (<strong>not</strong> pairs) to
communicate simultaneously.

all components to communicate simultaneously.

None of the above

packet switched architecture.

bus architecture.

circuit switched architecture.

fully connected architecture.

None of the above

an instruction fetch unit.

an instruction decoder.

an arithmetic logic unit.

a memory interface.

None of the above

are always grouped into sets of
"register windows".

are sometimes dedicated to specific
purposes (e.g., program counter, stack pointer).

are always general purpose, meaning
they can be used for any activity needing to use a register.

usually have the same number of bits as the address bus.

None of the above

pipelining

multi-register

hyperthreaded

multi-core

None of the above

desire to reduce single points of failure.

tradeoff between speed and cost for a given amount of memory.

difference between volatile and non-volatile memory technologies.

large amounts of certain types of memories.

None of the above

up to 10 million times slower than a register.

10-100 times slower than a solid state disk (SSD).

only 100 times slower than main memory (e.g., RAM).

1 million times slower than main memory (e.g., RAM).

None of the above

corresponding user level resource managers.

associated (physical) controllers.

device drivers by the operating system (OS).

associated command interpreter (e.g., shell) programs.

None of the above

Notify and Sleep

Busy waiting

Interrup driven

Direct Memory Access

None of the above

relinking the device driver object code with the OS kernel.

adding the device driver file to an OS config and rebooting.

adding the ".h" file to the OS config, recompiling the kernel,
and then rebooting the system.

dynamically loading the device driver code (no reboot).

None of the above

Direct Memory Access communication style.

Notify and Sleep communication style.

Busy waiting communication style.

Interrup driven communication style.

None of the above

Notify and Sleep communication style.

Busy waiting communication style.

Interrup driven communication style.

Direct Memory Access communication style.

None of the above

Notify and Sleep communication style.

Busy waiting communication style.

Interrup driven communication style.

Direct Memory Access communication style.

None of the above

all other interrupts are disabled to
ensure it completes.

only higher-priority interrupts are enabled.

all interrupts continue to be enabled,
since none should be missed.

only interrupts of the same kind are enabled.

None of the above

hard disk drive device driver to allow loading of the OS executable file.

Basic Input/Output System (BIOS).

OS executable file directly from the boot device (e.g., HDD, SSD).

GRand Unified Bootloader (GRUB).

None of the above

can only be used by the OS.

must never be used by the OS

are the OS interface for user programs.

are provided as a convenience, but aren't really necessary.

None of the above

programs are static (non-executing).

programs are never part of the
operating system.

processes also contain a run-time stack and program counter.

processes make use of system calls, but programs don't.

None of the above

must use system calls to accomplish
anything useful.

usually only directly communicates with its parent (or child) process(es).

may create a child process.

cannot use system calls unless it is being run by the
administrator/root user.

None of the above

are required to provide a signal handler.

can specify specific functions to be called when a particular
type of signal is received.

run the function named "sighand" to handle the signal.

run the specified signal handler function, which takes over
execution when the signal is received.

None of the above

programming language in which the code was written.

program source code file.

working directory in the file system.

user identification (uid).

None of the above

is the size of the program file for the process.

is the range of addressable bytes starting at 0 up to a maximum, usually
2^N - 1 (where N is the number of address bits).

is the amount of main memory initially
requested/needed by the process.

can be broken into smaller chunks so that programs larger than
the amount of main memory can be executed.

None of the above

processes.

user accounts.

programs.

files or directories.

None of the above

system call for accessing it.

working directory in the file system.

user identification (uid).

address space.

None of the above

files that the process currently has open.

any file in the file system that the process is permitted to access/open.

entries in the process' table of active/open files.

all directories with the same user
identification (uid) as the process.

None of the above

users to create new file systems.

hard disk drives (HDDs) to look like files.

keyboards and mice to look like files.

processes to directly communicate with one another.

None of the above

implements the details of all read/write
operations.

performs all of the cryptographic functions.

manages the devices attached to the computer.

enforces all of the OS security measures.

None of the above

an ordinary program that uses system calls to access the
capabilities of the OS.

a special program that directly implements all
of the available commands.

often called the "shell".

unique, with each system having only one such program available.

None of the above

Monolithic System

Layered System

Micorkernel

Client-Server

None of the above

Layered System

Micorkernel

Exokernel

Client-Server

None of the above

Layered System

Micorkernel

Exokernel

Client-Server

None of the above

Layered System

Micorkernel

Exokernel

Client-Server

None of the above

Monolithic System

Layered System

Micorkernel

Client-Server

None of the above

Minix v1

THE

Windows NT

MULTICS

None of the above

Minix v1

THE

Windows NT

MULTICS

None of the above

mimic any type of hardware so that older software can be run.

provide "copies" of the existing hardware so that multiple
operating systems can be run at the same time.

allow the remote (aka "virtual") execution of programs on
non-local hardware.

enable the use of virtual memory to run processes that require
a larger address space than is otherwise supported by the hardware.

None of the above

type 1 hypervisor.

type 2 hypervisor.

exokernel.

microkernel

None of the above

type 1 hypervisor.

type 2 hypervisor.

exokernel

microkernel

None of the above

type 1 hypervisor.

type 2 hypervisor.

exokernel

microkernel

None of the above

runs directly on the hardware and the operating systems run in
the hypervisor.

runs on top of the host OS (which is running directly on the
hardware). Additional operating systems run in the hypervisor.

divides the hardware up into slices, with each OS running
directly on the hardware. It ensures that each OS
only uses the parts of the hardware is was assigned.

provides a microkernel used by each of the operating systems
running in the hypervisor. Each OS uses the microkernel
system calls to interact with the hardware.

None of the above

runs directly on the hardware and the operating systems run in
the hypervisor.

runs on top of the host OS (which is running directly on the
hardware). Additional operating systems run in the hypervisor.

divides the hardware up into slices, with each OS running
directly on the hardware. It ensures that each OS
only uses the parts of the hardware is was assigned.

provides a microkernel used by each of the operating systems
running in the hypervisor. Each OS uses the microkernel
system calls to interact with the hardware.

None of the above

runs directly on the hardware and the operating systems run in
the hypervisor.

runs on top of the host OS (which is running directly on the
hardware). Additional operating systems run in the hypervisor.

divides the hardware up into slices, with each OS running
directly on the hardware. It ensures that each OS
only uses the parts of the hardware is was assigned.

provides a microkernel used by each of the operating systems
running in the hypervisor. Each OS uses the microkernel
system calls to interact with the hardware.

None of the above

type 1 hypervisor

type 2 hypervisor

microkernel

exokernel

None of the above

parallelism

pseudoparallelism

hyperthreading

multiprocessing

None of the above

letting each process run to completion.

executing each process until it blocks before running the next process.

running exactly one instruction from each process in
round-robin fashion.

rapidly switching of the CPU between processes (multiprogramming).

None of the above

another name for a program.

the compiled (executable) version of a program.

a program in execution.

a program that is either running (in the CPU) or ready, but
not blocked.

None of the above

task manager

pwd

ps

listAll

None of the above

task manager

pwd

ps

listAll

none of the above

Normal

Error

Fatal

Killed

None of the above

Killed

Normal

Error

Fatal

None of the above

each process corresponds to a program file (and files are hierarchical).

except for the first process, all other
processes are created by an existing process.

each process corresponds to a user identification, and uids are
arranged hierarchically.

of the time frames in which they were created.

None of the above

Running

Blocked

Ready

Waiting

None of the above

running to blocked

running to ready

ready to running

blocked to running

None of the above

running to blocked

running to ready

ready to running

ready to blocked

None of the above

ready to blocked

blocked to ready

running to ready

ready to running

None of the above

running to blocked

running to ready

blocked to running

blocked to ready

None of the above

Running

Blocked

Ready

Waiting

None of the above

Running

Blocked

Ready

Waiting

None of the above

the file of the corresponding program.

only the current program counter for that process.

only the process id number for that process.

all of the associated information for a
single process.

None of the above

Running

Blocked

Ready

Waiting

None of the above

new

create

dup

fork

None of the above

replace

exec

dup2

getpid

None of the above

wait

waitpid

fini

done

getpid

send a signal to another process.

declare what signals may be sent to a process.

respond back to a signal sent from another process.

indicate which function should be called when a particular
signal is received by the process.

None of the above

wait

break

pause

block

None of the above

hyperthreads

lightweight processes

execution traces

shared libraries

None of the above

are more limited in the size of their address space.

cannot be used for multiprogramming.

take the same amount of time for a context switch.

can be created and destroyed 10-100 times faster.

None of the above

address space.

program counter.

run-time stack.

state (blocked, ready, running).

None of the above

one thread.

two threads, one each for execution and garbage collection.

three threads, for execution, signal management, and garbage collection.

one child process.

None of the above

Program counter

Address space

Static variables

Run-time stack

Heap storage

Registers

File descriptors

Signal handlers

State (blocked, ready, running)

None of the above

Program counter

Address space

Static variables

Run-time stack

Heap storage

Registers

File descriptors

Signal handlers

State (blocked, ready, running)

None of the above

calling the same function from multiple threads.

reading/setting values for the same static variables and heap
allocated objects from multiple threads.

creating new threads.

a thread terminates.

None of the above

pthread_new

pthread_fork

pthread_create

pthread_dup

None of the above

pthread_getid

pthread_self

pthread_pid

pthread_thread_id

None of the above

pthread_exit

pthread_terminate

pthread_yield

pthread_return

None of the above

pthread_wait

pthread_block

pthread_pause

pthread_join

None of the above

pthread_block

pthread_yield

pthread_stop

pthread_pause

None of the above

require the OS to be thread aware.

require the process to keep track of the threads via a thread
table (in addition to the process table that the OS maintains).

enable context switching that is about 10x faster than kernel space threads.

cause the entire process to block if any one of its threads blocks
for a system resource.

None of the above

requires the OS to be thread aware.

requires the process to keep track of the threads via a thread
table (in addition to the process table that the OS maintains).

enables context switching that is about 10x faster than
user/process space threads.

cause the entire process to block if any one of its threads blocks
for a system resource.

None of the above

are assigned as requested to reduce the costs of thread creation
and destruction.

are only beneficial for user/process space managed threads.

are only beneficial for kernel space managed threads.

prevent an over abundance of threads, if the pool is the only
means for acquiring a thread.

None of the above

one or more kernel threads to a process, with the process able
to start multiple user threads within each kernel thread.

exactly one user space and one kernel space thread to each process.

any number of user space and kernel space threads to each process as long as
they are requested from the corresponding user and kernel thread pools.

only user space threads, but enables the kernel to recognize when
a user thread is blocked.

None of the above

kernel space threads, but only the process schedules them.

kernel space threads, but the process recommends to the OS
which thread to schedule/run next.

user space threads, but the kernel recognizes when a blocked
thread doesn't prevent other threads from running.

both user and kernel space threads for a process, with each
thread type being scheduled as it normally would be.

None of the above

message passing.

sharing information.

semaphores

sequencing process interactions.

None of the above

two or more processes share the same variable.

only user space threads are used for multiprogramming.

only kernel space threads are used for multiprogramming.

different execution orderings of instructions in multiple threads/processes
can produce different results.

None of the above

two or more threads/processes can read (but
not change) the same variable(s).

two or more threads/processes can read and write the same
variable(s) via UNinterruptible actions.

two or more threads/processes can read and write the same
variable(s) via interruptible actions.

when there is a mix of user space and kernel space threads
within the same process, but no shared variable(s).

None of the above

that makes system calls.

in which only one thread (or process) should be active at a time.

that is protected by one or more semaphores.

which is shared by multiple threads.

None of the above

larger critical sections run more slowly.

this reduces the amount of process blocking.

there is a maximum code size for which semaphores will work.

they must run completely through
without blocking.

None of the above

No 2 threads/processes are in their critical sections at the same time.

No assumptions are made about process execution speeds.

No thread/process should wait arbitrarily long to enter its
critical section.

No thread/process outside its critical section should block other
threads/processes.

None of the above

it requires process threads to run in kernel space.

it requires process threads to run in user space.

a user program could use this to hog the CPU.

it fails to work if there are multiple CPUs.

None of the above

is only suitable if the expected wait time is very short.

solution only works for two processes (or threads).

solution only works if there is only a single CPU involved.

is wasteful of the CPU resource.

None of the above

disabling interrupts.

kernel space threads.

lock variable(s).

busy waiting.

None of the above

runs with interrupts disabled.

does the value copy and set as a single indivisible action.

works by performing the busy wait within a single instruction.

locks the memory bus.

None of the above

the busy waiting process/thread has a higher priority.

the busy waiting process/thread has a lower priority.

the busy waiting process/thread is a user space thread.

the busy waiting process/thread is a kernel space thread.

None of the above

only being callable by the OS (and not by
user programs).

saving the current value of a register while the register's
value is set to a new value.

blocks if the value being assigned is different from the current
value of the register.

that it is atomic (i.e., cannot be interrupted once begun).

None of the above

wakeup signals are not
buffered.

sleep cannot be called by an already blocked process.

only strict alternation of critical sections is implemented.

wakeup is never called
first.

None of the above

strictly alternating critical sections to be protected
without busy waiting.

2) strictly alternating critical sections to be protected but only
when a test and set instruction is available.

the protection of any critical section so long as
wakeup is never
called first.

the protection of any critical section so long as
sleep is never
called twice in a row.

None of the above

sleep only blocks a process for a maximum period of
time.

sleep cannot be called by an already blocked process.

wakeup cannot unblock a process that called
sleep twice in a row.

wakeup calls are not
buffered.

None of the above

Gary Peterson

Andrew Tannenbaum

Edgar Dijkstra

Alan Turing

count--; if (count <= 0) { sleep(); }

sleep(); if (count <= 0) { count--; }

if (count <= 0) { count--; } sleep();

if (count <= 0) { sleep(); } count--;

if (count == 1) { wakeup(sleeping_process); } count++;

if (count == 1) { count++; } wakeup(sleeping_process);

wakeup(sleeping_process); if (count == 1) { count++; }

count++; if (count == 1) { wakeup(sleeping_process); }

total times that the semaphore can be used (e.g., P/DOWN operations).

available items of that resource.

different types of resources.

concurrent processes (but not threads)
that can share the resource(s).

P/DOWN is the equivalent of checking out a book.

P/DOWN is the equivalent of returning a book.

V/UP is the equivalent of checking out a book.

V/UP is the equivalent of returning a book.