Anda di halaman 1dari 4

Group Policy, in part, controls what users can and cannot do on a computer system.

A GPO
that resides on a single machine only applies to that computer. To apply a GPO to a group of
computers, Group Policy relies on Active Directory. Active Directory can distribute GPOs to
computers which belong to a Windows domain.
Policy settings are divided into policy settings that affect a computer and policy settings that
affect a user. Computer-related policies specify system behavior, application settings, security
settings, assigned applications, and computer startup and shutdown scripts. User-related
policies specify system behavior, application settings, security settings, assigned and
published applications, user logon and logoff scripts, and folder redirection. Be aware that
computer-related settings override user-related settings.

PART 2
Group Policy Objects are processed in the following order (from top to bottom):[4]

Local - Any settings in the computer's local policy. Prior to Windows Vista, there was only one
local group policy stored per computer. Windows Vista and later Windows versions allow
individual group policies per user accounts.[5]
Site - Any Group Policies associated with the Active Directory site in which the computer
resides. (An Active Directory site is a logical grouping of computers, intended to facilitate
management of those computers based on their physical proximity.) If multiple policies are
linked to a site, they are processed in the order set by the administrator.
Domain - Any Group Policies associated with the Windows domain in which the computer
resides. If multiple policies are linked to a domain, they are processed in the order set by the
administrator.
Organizational Unit - Group policies assigned to the Active Directory organizational unit (OU)
in which the computer or user are placed. (OUs are logical units that help organizing and
managing a group of users, computers or other Active Directory objects.) If multiple policies
are linked to an OU, they are processed in the order set by the administrator.
The resulting Group Policy settings applied to a given computer or user are known as the
Resultant Set of Policy (RSoP). RSoP information may be displayed for both computers and
users using the gpresult command.[6]

Part 3.
A policy setting inside a hierarchical structure is ordinarily passed from parent to children, and
from children to grandchildren, and so forth. This is termed inheritance. It can be blocked or
enforced to control what policies are applied at each level.
Blocking inheritance prevents Group Policy objects (GPOs) that are linked to higher sites,
domains, or organizational units from being automatically inherited by the child-level.
Enforced setting in a GPO link take precedence over the settings of any child object. GPO-links
that are enforced cannot be blocked from the parent container. It even overrides the Block
Inheritance setting.

Q11.
Part 1 Option B 1.538 Mbps
Total data sent = 100,000 bytes
Number of packets = total data sent / (payload + header)
= 100,000 / (1000 + 40) = 96
Total useful data sent = number of packets * payload size
= 96 * 1000 Bytes = 96 * 1000 * 8 bits
Goodput = Total number of bits / time taken
= (96 * 1000 * 8 ) / 0.5 = 1.538 Mbps

Part 2. Option C. (Determined by number of packets buffered at a router


Transmission delay is a function of the packet's length and has nothing to do with the distance
between the two nodes. This delay is proportional to the packet's length in bits,

It is given by the following formula:

DT=N/R seconds
where

DT is the transmission delay in seconds


N is the number of bits, and
R is the rate of transmission (say in bits per second)

Part C
Option B. Run ping test to remote host, check port status, ..
the bottom-up approach starts with an exhaustive check of all the elements of each layer, starting with the physical
layer, and works its way up.
/**************************************************************************
* Compilation: javac Ball.java
* Execution: java Ball
* Dependencies: StdDraw.java
*
* Implementation of a 2-d Ball moving in square Bounces off the walls *
* upon collision.
**************************************************************************/
public class Ball {

// instance variables
private double rx, ry; // position
private double vx, vy; // velocity
private final double radius; // radius
// constructor
public Ball() {
rx = 0.0;
ry = 0.0;
vx = StdRandom.uniform(-0.015, 0.015);
vy = StdRandom.uniform(-0.015, 0.015);
radius = StdRandom.uniform(0.025, 0.075);
}

// bounce of vertical wall by reflecting x-velocity


private void bounceOffVerticalWall() {
vx = -vx;
}
// bounce of horizontal wall by reflecting y-velocity
private void bounceOffHorizontalWall() {
vy = -vy;
}
// move the ball one step
public void move() {
if (Math.abs(rx + vx) + radius > 1.0) bounceOffVerticalWall();
if (Math.abs(ry + vy) + radius > 1.0) bounceOffHorizontalWall();
rx = rx + vx;
ry = ry + vy;
}
// draw the ball
public void draw() {
StdDraw.filledCircle(rx, ry, radius);
}
// test client
public static void main(String[] args) {
// create and initialize two balls
Ball b1 = new Ball();
// animate them
StdDraw.setXscale(-1.0, +1.0);
StdDraw.setYscale(-1.0, +1.0);
StdDraw.enableDoubleBuffering();
while (true) {
StdDraw.clear(StdDraw.GRAY);
StdDraw.setPenColor(StdDraw.BLACK);
b1.move();
b1.draw();
StdDraw.show();
StdDraw.pause(20);
}
}
}
Q12. Part 1
With two-level PTs, virtual addresses have 3 parts:
master page number, secondary page number, offset
master PT maps master PN to secondary PT
secondary PT maps secondary PN to page frame number
offset + PFN = physical address

Given is Master page table = 4KB and each entry = 4Bytes


Number of possible Secondary PT = 4KB/4B = 1024 entries

Number of level 2 page tables: 4GB / 4MB = 1024 entries

Our two-level page table consumes (1024 level-0 entries) (4 bytes/entry) + (1024
level-1 entries) (4 bytes/entry) = 2 4 210 bytes = 8 kbytes.

Part2
Total number of entries in Hash table = 212 = 4 X 1024 = 4096 entries
Each entry takes 8 bytes
Total Hash table size = 4096 X 8 Bytes = 32 KB

Part 3
With 64 bit logical address and page size of 4KB (212)
Since page table must fit in a page, page table size is 4096 bytes and each entry is 4
bytes thus a table holds 4096/4=1024 entries. To address 1024 entries it requires log2(1024)=
10 bits. The total number of bits available to encode the entry for each page level is 64-
log2(4096)=52 bits (the number of bits of address space minus the page offset bits). Thus the
total number of levels required is 52/10=6 (rounded up).