text:
Sub-menu: /interface bridge
Standards: IEEE802.1D
Ethernet-like networks (Ethernet, Ethernet over IP, IEEE802.11 in ap-bridge or bridge mode, WDS, VLAN) can be connected together using MAC bridges. The bridge feature allows the interconnection of hosts connected to separate LANs (using EoIP, geographically distributed networks can be bridged as well if any kind of IP network interconnection exists between them) as if they were attached to a single LAN. As bridges are transparent, they do not appear in traceroute list, and no utility can make a distinction between a host working in one LAN and a host working in another LAN if these LANs are bridged (depending on the way the LANs are interconnected, latency and data rate between hosts may vary).
Network loops may emerge (intentionally or not) in complex topologies. Without any special treatment, loops would prevent network from functioning normally, as they would lead to avalanche-like packet multiplication. Each bridge runs an algorithm which calculates how the loop can be prevented. STP and RSTP allows bridges to communicate with each other, so they can negotiate a loop free topology. All other alternative connections that would otherwise form loops, are put to standby, so that should the main connection fail, another connection could take its place. This algorithm exchanges configuration messages (BPDU - Bridge Protocol Data Unit) periodically, so that all bridges are updated with the newest information about changes in network topology. (R)STP selects a root bridge which is responsible for network reconfiguration, such as blocking and opening ports on other bridges. The root bridge is the bridge with the lowest bridge ID.
Bridge Interface Setup
Sub-menu: /interface bridge
To combine a number of networks into one bridge, a bridge interface should be created (later, all the desired interfaces should be set up as its ports). One MAC address will be assigned to all the bridged interfaces (the MAC address of first bridge port which comes up will be chosen automatically).
Property | Description |
admin-mac (MAC address; Default: ) | Static MAC address of the bridge (takes effect if auto-mac=no ) |
ageing-time (time; Default: 00:05:00) | How long a host's information will be kept in the bridge database |
arp (disabled | enabled | proxy-arp | reply-only; Default: enabled) | Address Resolution Protocol setting
auto-mac (yes | no; Default: yes) | Automatically select one MAC address of bridge ports as a bridge MAC address |
fast-forward (yes | no; Default: yes) | Special and faster case of Fast Path which works only on bridges with 2 interfaces (enabled by default only for new bridges) |
forward-delay (time; Default: 00:00:15) | Time which is spent during the initialization phase of the bridge interface (i.e., after router startup or enabling the interface) in listening/learning state before the bridge will start functioning normally |
l2mtu (integer; read-only) | Layer2 Maximum transmission unit. read more» |
max-message-age (time; Default: 00:00:20) | How long to remember Hello messages received from other bridges |
mtu (integer; Default: 1500) | Maximum Transmission Unit |
name (text; Default: bridgeN) | Name of the bridge interface |
priority (integer: 0..65535 decimal format or 0x0000-0xffff hex format; Default: 32768 / 0x8000) |
Spanning tree protocol priority for bridge interface. Bridge with the smallest (lowest) bridge ID becomes a Root-Bridge. Bridge ID consists of two numbers - priority and MAC address of the bridge. To compare two bridge IDs, the priority is compared first. If two bridges have equal priority, then the MAC addresses are compared. |
protocol-mode (none | rstp | stp; Default: rstp) | Select Spanning tree protocol (STP) or Rapid spanning tree protocol (RSTP) to ensure a loop-free topology for any bridged LAN. RSTP provides for faster spanning tree convergence after a topology change. |
transmit-hold-count (integer: 1..10; Default: 6) | The Transmit Hold Count used by the Port Transmit state machine to limit transmission rate |
(Rapid) Spanning Tree Protocol
To add and enable a bridge interface that will forward all the protocols:
[admin@CableFree] /interface bridge> add [admin@CableFree] /interface bridge> print Flags: X - disabled, R - running 0 R name="bridge1" mtu=1500 l2mtu=65535 arp=enabled mac-address=00:00:00:00:00:00 protocol-mode=none priority=0x8000 auto-mac=yes admin-mac=00:00:00:00:00:00 max-message-age=20s forward-delay=15s transmit-hold-count=6 ageing-time=5m [admin@CableFree] /interface bridge>
Bridge Settings
Sub-menu: /interface bridge settings
Property | Description |
use-ip-firewall (yes | no; Default: no) | Force bridged traffic to also be processed by prerouting, forward and postrouting sections of IP routing. This does not apply to routed traffic. |
use-ip-firewall-for-pppoe (yes | no; Default: no) | Send bridged un-encrypted PPPoE traffic to also be processed by 'IP firewall' (requires use-ip-firewall=yes to work) |
use-ip-firewall-for-vlan (yes | no; Default: no) | Send bridged VLAN traffic to also be processed by 'IP firewall' (requires use-ip-firewall=yes to work) |
allow-fast-path (yes | no; Default: yes) | Allows fast path |
bridge-fast-path-active (yes | no; Default: ) | Shows whether Bridge Fast Path is active |
bridge-fast-path-packets (integer; Default: ) | Shows packet count forwarded by Bridge Fast Path |
bridge-fast-path-bytes (integer; Default: ) | Shows byte count forwarded by Bridge Fast Path |
bridge-fast-forward-packets (integer; Default: ) | Shows packet count forwarded by Bridge Fast Forward |
bridge-fast-forward-bytes (integer; Default: ) | Shows byte count forwarded by Bridge Fast Forward |
Port Settings
Sub-menu: /interface bridge port
Port submenu is used to enslave interfaces in a particular bridge interface.
Property | Description |
auto-isolate (yes | no; Default:no) | Prevents STP blocking port from erroneously moving into a forwarding state if no BPDU's are received on the bridge. |
bridge (name; Default: none) | The bridge interface the respective interface is grouped in |
edge (auto | no | no-discover | yes | yes-discover; Default: auto) | Set port as edge port or non-edge port, or enable automatic detection. Edge ports are connected to a LAN that has no other bridges attached. If the port is configured to discover edge port then as soon as the bridge detects a BPDU coming to an edge port, the port becomes a non-edge port. |
external-fdb (auto | no | yes; Default: auto) | Whether to use wireless registration table to speed up bridge host learning |
horizon (none | integer 0..429496729; Default: none) | Use split horizon bridging to prevent bridging loops. read more» |
interface (name; Default: none) | Name of the interface |
path-cost (integer: 0..65535; Default: 10) | Path cost to the interface, used by STP to determine the "best" path |
point-to-point (auto | yes | no; Default: auto) | |
priority (integer: 0..240; Default: 128) (i=dec*16 dec={0..15}) (i=hex*0x10 hex={0x0..0xF}) | The priority of the interface in comparison with other going to the same subnet |
To group ether1 and ether2 in the already created bridge1 bridge
[admin@CableFree] /interface bridge port> add bridge=bridge1 interface=ether1 [admin@CableFree] /interface bridge port> add bridge=bridge1 interface=ether2 [admin@CableFree] /interface bridge port> print Flags: X - disabled, I - inactive, D - dynamic # INTERFACE BRIDGE PRIORITY PATH-COST HORIZON 0 ether1 bridge1 0x80 10 none 1 ether2 bridge1 0x80 10 none [admin@CableFree] /interface bridge port>
Bridge Monitoring
Sub-menu: /interface bridge monitor
Used to monitor the current status of a bridge.
Property | Description |
current-mac-address (MAC address) | Current MAC address of the bridge |
designated-port-count (integer) | Number of designated bridge ports |
port-count (integer) | Number of the bridge ports |
root-bridge (yes | no) | Shows whether bridge is the root bridge of the spanning tree |
root-bridge-id (text) | The root bridge ID, which is in form of bridge-priority.bridge-MAC-address |
root-path-cost (integer) | The total cost of the path to the root-bridge |
root-port (name) | Port to which the root bridge is connected to |
state (enabled | disabled) | State of the bridge |
To monitor a bridge:
[admin@CableFree] /interface bridge> monitor bridge1 state: enabled current-mac-address: 00:0C:42:52:2E:CE root-bridge: yes root-bridge-id: 0x8000.00:00:00:00:00:00 root-path-cost: 0 root-port: none port-count: 2 designated-port-count: 0 [admin@CableFree] /interface bridge>
Bridge Port Monitoring
Sub-menu: /interface bridge port monitor
Statistics of an interface that belongs to a bridge.
Property | Description |
edge-port (yes | no) | Whether port is an edge port or not |
edge-port-discovery (yes | no) | Whether port is set to automatically detect edge ports |
external-fdb (yes | no) | Shows whether registration table is used instead of forwarding data base |
forwarding (yes | no) | Port state |
learning (yes | no) | Port state |
port-number (integer 1..4095) | Port identifier |
point-to-point-port (yes | no) | |
role (designated | root port | alternate | backup | disabled) |
(R)STP algorithm assigned role of the port:
sending-rstp (yes | no) | Whether the port is sending BPDU messages |
status (in-bridge | inactive) | Port status |
To monitor a bridge port:
[admin@CableFree] /interface bridge port> monitor 0 status: in-bridge port-number: 1 role: designated-port edge-port: no edge-port-discovery: yes point-to-point-port: no external-fdb: no sending-rstp: no learning: yes forwarding: yes [admin@CableFree] /interface bridge port>
Bridge Host Monitoring
Sub-menu: /interface bridge host
Property | Description |
age (read-only: time) | The time since the last packet was received from the host |
bridge (read-only: name) | The bridge the entry belongs to |
external-fdb (read-only: flag) | Whether the host was learned using wireless registration table |
local (read-only: flag) | Whether the host entry is of the bridge itself (that way all local interfaces are shown) |
mac-address (read-only: MAC address) | Host's MAC address |
on-interface (read-only: name) | Which of the bridged interfaces the host is connected to |
To get the active host table:
[admin@CableFree] /interface bridge host> print Flags: L - local, E - external-fdb BRIDGE MAC-ADDRESS ON-INTERFACE AGE bridge1 00:00:00:00:00:01 ether2 3s bridge1 00:01:29:FF:1D:CC ether2 0s L bridge1 00:0C:42:52:2E:CF ether2 0s bridge1 00:0C:42:52:2E:D0 ether2 3s bridge1 00:0C:42:5C:A5:AE ether2 0s [admin@CableFree] /interface bridge host>
Bridge VLAN Filtering
Bridge VLAN Filtering since RadioOS v6.40rc29 provides VLAN aware Layer2 forwarding and VLAN tag modifications within the bridge. This set of features makes bridge operation more like a traditional Ethernet switch and allows to overcome Spanning Tree compatibilty issues compared to configuration when tunnel-like VLAN interfaces are bridged. Bridge VLAN Filtering configuration is highly recommended to comply with STP (802.1D), RSTP (802.1w) standards and is mandatory to enable MSTP (802.1s) support in RadioOS.
Sub-menu: /interface bridge
The main VLAN setting is vlan-filtering
which globally controls vlan-awareness and VLAN tag processing in the bridge.
If vlan-filtering=no
, bridge ignores VLAN tags, works in a shared-VLAN-learning (SVL) mode and cannot modify VLAN tags of packets.
Turning on vlan-filtering
enables all bridge VLAN related functionality and independent-VLAN-learning (IVL) mode.
Besides joining the ports for Layer2 forwarding, bridge itself is also an interface therefore it has Port VLAN ID (pvid).
Property | Description |
vlan-filtering (yes | no; Default:no) | Globally enables or disables VLAN functionality for bridge. |
pvid (1..4094; Default:1) | Port VLAN ID (pvid) specifies which VLAN the untagged ingress traffic is assigned to. It applies e.g. to frames sent from bridge IP and destined to a bridge port. |
Sub-menu: /interface bridge port
The bridge port settings related to vlan filtering are described below.
Property | Description |
frame-types (admit-all | admit-only-untagged-and-priority-tagged | admit-only-vlan-tagged; Default:admit-all) | Specifies allowed ingress frame types on a bridge port. |
ingress-filtering (yes | no; Default:no) | Enables or disables filtering which looks for an ingress port match in the Bridge VLAN table. |
pvid (1..4094; Default:1) | Port VLAN ID (pvid) specifies which VLAN the untagged ingress traffic is assigned to. |
Sub-menu: /interface bridge vlan
Bridge VLAN table represents per-VLAN port mapping with an egress VLAN tag action.
ports send out frames with a learned VLAN ID tag.
ports remove VLAN tag before sending out frames if the learned VLAN ID matches the port pvid
Property | Description |
bridge (name) | The bridge interface which the respective VLAN entry is intended for. |
disabled (yes | no; Default:no) | Enables or disables Bridge VLAN entry. |
tagged (interfaces; Default:none) | Interface list with a VLAN tag adding action in egress. This setting accepts comma separated values. E.g. tagged=ether1,ether2 . |
untagged (interfaces; Default:none) | Interface list with a VLAN tag removing action in egress. This setting accepts comma separated values. E.g. tagged=ether3,ether4 . |
vlan-ids (1..4094) | The list of VLAN IDs for certain port configuration. This setting accepts VLAN ID range as well as comma separated values. E.g. vlan-ids=100-115,120,122,128-130 . |
Sub-menu: /interface bridge host
Bridge Host table allows monitoring learned MAC addresses and when vlan-filtering
is enabled shows learned VLAN ID as well.
[admin@CableFree] > interface bridge host print where !local Flags: L - local, E - external-fdb BRIDGE VID MAC-ADDRESS ON-INTERFACE AGE bridge1 200 D4:CA:6D:77:2E:F0 ether3 7s bridge1 200 E4:8D:8C:1B:05:F0 ether2 2s bridge1 300 D4:CA:6D:74:65:9D ether4 3s bridge1 300 E4:8D:8C:1B:05:F0 ether2 2s bridge1 400 4C:5E:0C:4B:89:5C ether5 0s bridge1 400 E4:8D:8C:1B:05:F0 ether2 0s [admin@CableFree] >
VLAN Example #1 (Trunk and Access Ports)
- Create a bridge with disabled
to avoid losing access to the router before VLANs are completely configured.
/interface bridge add name=bridge1 vlan-filtering=no
- Add bridge ports and specify
for VLAN access ports to assign their untagged traffic to the intended VLAN.
/interface bridge port add bridge=bridge1 interface=ether2 add bridge=bridge1 interface=ether6 pvid=200 add bridge=bridge1 interface=ether7 pvid=300 add bridge=bridge1 interface=ether8 pvid=400
- Add Bridge VLAN entries and specify tagged and untagged ports in them.
/interface bridge vlan add bridge=bridge1 tagged=ether2 untagged=ether6 vlan-ids=200 add bridge=bridge1 tagged=ether2 untagged=ether7 vlan-ids=300 add bridge=bridge1 tagged=ether2 untagged=ether8 vlan-ids=400
- In the end, when VLAN configuration is complete, enable Bridge VLAN Filtering.
/interface bridge set bridge1 vlan-filtering=yes
VLAN Example #2 (Trunk and Hybrid Ports)
- Create a bridge with disabled
to avoid losing access to the router before VLANs are completely configured.
/interface bridge add name=bridge1 vlan-filtering=no
- Add bridge ports and specify
on hybrid VLAN ports to assign untagged traffic to the intended VLAN.
/interface bridge port add bridge=bridge1 interface=ether2 add bridge=bridge1 interface=ether6 pvid=200 add bridge=bridge1 interface=ether7 pvid=300 add bridge=bridge1 interface=ether8 pvid=400
- Add Bridge VLAN entries and specify tagged and untagged ports in them. In this example egress VLAN tagging is done on ether6,ether7,ether8 ports too, making them into hybrid ports.
/interface bridge vlan add bridge=bridge1 tagged=ether2,ether7,ether8 untagged=ether6 vlan-ids=200 add bridge=bridge1 tagged=ether2,ether6,ether8 untagged=ether7 vlan-ids=300 add bridge=bridge1 tagged=ether2,ether6,ether7 untagged=ether8 vlan-ids=400
- In the end, when VLAN configuration is complete, enable Bridge VLAN Filtering.
/interface bridge set bridge1 vlan-filtering=yes
VLAN Example #3 (InterVLAN Routing by Bridge)
- Create a bridge with disabled
to avoid losing access to the router before VLANs are completely configured.
/interface bridge add name=bridge1 vlan-filtering=no
- Add bridge ports and specify
for VLAN access ports to assign their untagged traffic to the intended VLAN.
/interface bridge port add bridge=bridge1 interface=ether6 pvid=200 add bridge=bridge1 interface=ether7 pvid=300 add bridge=bridge1 interface=ether8 pvid=400
- Add Bridge VLAN entries and specify tagged and untagged ports in them. In this example bridge1 interface is the VLAN trunk that will send traffic further to do InterVLAN routing.
/interface bridge vlan add bridge=bridge1 tagged=bridge1 untagged=ether6 vlan-ids=200 add bridge=bridge1 tagged=bridge1 untagged=ether7 vlan-ids=300 add bridge=bridge1 tagged=bridge1 untagged=ether8 vlan-ids=400
- Configure VLAN interfaces on the bridge1 to allow handling of tagged VLAN traffic at routing level and set IP addresses to ensure routing between VLANs as planned.
/interface vlan add interface=bridge1 name=vlan200 vlan-id=200 add interface=bridge1 name=vlan300 vlan-id=300 add interface=bridge1 name=vlan400 vlan-id=400 /ip address add address=22.214.171.124/24 interface=vlan200 network=188.8.131.52 add address=126.96.36.199/24 interface=vlan300 network=126.96.36.199 add address=188.8.131.52/24 interface=vlan400 network=220.127.116.11
- In the end, when VLAN configuration is complete, enable Bridge VLAN Filtering.
/interface bridge set bridge1 vlan-filtering=yes
Management port
There are multiple ways to setup management port on a device that uses bridge VLAN filtering. Below are some of the most popular approaches to properly enable access to a router/switch. Start by creating a bridge without VLAN filtering enabled:
/interface bridge add name=bridge1 vlan-filtering=no
- In case VLAN filtering will not be used and access with untagged traffic is desired
The only requirement is to create an IP address on the bridge interface.
/ip address add address=192.168.99.1/24 interface=bridge1
- In case VLAN filtering is used and access from trunk and/or access ports with tagged traffic is desired
In this example VID99 will be used to access the device, a VLAN interface on the bridge must be created and an IP address must be assigned to it.
/interface vlan add interface=bridge name=MGMT vlan-id=99 /ip address add address=192.168.99.1/24 interface=MGMT
For example, if you want to allow access to the router/switch from access ports ether3,ether4 and from trunk port sfp-sfpplus1, then you must add this entry to the VLAN table:
/interface bridge vlan add bridge=bridge1 tagged=bridge1,ether3,ether4,sfp-sfpplus1 vlan-ids=99
After that you can enable VLAN filtering:
/interface bridge set bridge1 vlan-filtering=yes
- In case VLAN filtering is used and access from trunk and/or access ports with untagged traffic is desired
To allow untagged traffic to access the router/switch, start by creating an IP address on the bridge interface.
/ip address add address=192.168.88.1/24 interface=bridge1
It is required to add VID1 to ports from which you want to allow the access to the router/switch, for example, to allow access from access ports ether3,ether4 add this entry to the VLAN table:
/interface bridge vlan add bridge=bridge1 untagged=ether3,ether4 vlan-ids=1
After that you can enable VLAN filtering:
/interface bridge set bridge1 vlan-filtering=yes
Note: If connection to the router/switch through an IP address is not required, then steps adding this IP address can be skipped since connection to the router/switch through Layer2 protocols (e.g. MAC-telnet) will be working either way.
IGMP Snooping
IGMP Snooping which controls multicast streams and prevents multicast flooding is implemented in RadioOS starting from version 6.41.
It's settings are placed in bridge menu and it works independently in every bridge interface.
Software driven implementation works on all devices with RadioOS but CRS1xx/2xx/3xx series switches also support IGMP Snooping with hardware offloading.
Sub-menu: /interface bridge
/interface bridge mdb
- Enabling IGMP Snooping on Bridge.
/interface bridge set bridge1 igmp-snooping=yes
- Monitoring multicast groups in the Bridge Multicast Database
[admin@CableFree] > interface bridge mdb print BRIDGE VID GROUP PORTS bridge1 200 184.108.40.206 ether3 ether2 ether1 bridge1 300 126.96.36.199 ether4 ether3 ether2 bridge1 400 188.8.131.52 ether4 ether3 bridge1 500 188.8.131.52 ether5 ether1 [admin@CableFree] >
Bridge Firewall
Sub-menu: /interface bridge filter, /interface bridge nat
The bridge firewall implements packet filtering and thereby provides security functions that are used to manage data flow to, from and through bridge.
Packet flow diagram shows how packets are processed through router. It is possible to force bridge traffic to go through /ip firewall filter
rules (see: Bridge Settings)
There are two bridge firewall tables:
- filter - bridge firewall with three predefined chains:
- input - filters packets, where the destination is the bridge (including those packets that will be routed, as they are destined to the bridge MAC address anyway)
- output - filters packets, which come from the bridge (including those packets that has been routed normally)
- forward - filters packets, which are to be bridged (note: this chain is not applied to the packets that should be routed through the router, just to those that are traversing between the ports of the same bridge)
- nat - bridge network address translation provides ways for changing source/destination MAC addresses of the packets traversing a bridge. Has two built-in chains:
- srcnat - used for "hiding" a host or a network behind a different MAC address. This chain is applied to the packets leaving the router through a bridged interface
- dstnat - used for redirecting some packets to other destinations
You can put packet marks in bridge firewall (filter and NAT), which are the same as the packet marks in IP firewall put by '/ip firewall mangle'
. In this way, packet marks put by bridge firewall can be used in 'IP firewall', and vice versa.
General bridge firewall properties are described in this section. Some parameters that differ between nat and filter rules are described in further sections.
Property | Description |
802.3-sap (integer) | DSAP (Destination Service Access Point) and SSAP (Source Service Access Point) are 2 one byte fields, which identify the network protocol entities which use the link layer service. These bytes are always equal. Two hexadecimal digits may be specified here to match a SAP byte |
802.3-type (integer) | Ethernet protocol type, placed after the IEEE 802.2 frame header. Works only if 802.3-sap is 0xAA (SNAP - Sub-Network Attachment Point header). For example, AppleTalk can be indicated by SAP code of 0xAA followed by a SNAP type code of 0x809B |
arp-dst-address (IP address; default: ) | ARP destination address |
arp-dst-mac-address (MAC address; default: ) | ARP destination MAC address |
arp-gratuitous (yes | no; default: ) | Matches ARP gratuitous packets |
arp-hardware-type (integer; default: 1) | ARP hardware type. This is normally Ethernet (Type 1) |
arp-opcode (arp-nak | drarp-error | drarp-reply | drarp-request | inarp-reply | inarp-request | reply | reply-reverse | request | request-reverse) |
ARP opcode (packet type)
arp-packet-type (integer: 0..65535 decimal format or 0x0000-0xffff hex format) | ARP Packet Type |
arp-src-address (IP address; default: ) | ARP source address |
arp-src-mac-address (MAC address; default: ) | ARP source MAC address |
chain (text) | Bridge firewall chain, which the filter is functioning in (either a built-in one, or a user defined) |
dst-address (IP address; default: ) | Destination IP address (only if MAC protocol is set to IPv4) |
dst-mac-address (MAC address; default: ) | Destination MAC address |
dst-port (integer 0..65535) | Destination port number or range (only for TCP or UDP protocols) |
in-bridge (name) | Bridge interface through which the packet is coming in |
in-interface (name) | Physical interface (i.e., bridge port) through which the packet is coming in |
ingress-priority (integer 0..63) | Matches ingress priority of the packet. Priority may be derived from VLAN, WMM or MPLS EXP bit. read more» |
ip-protocol (ddp | egp | encap | etherip | ggp | gre | hmp | icmp | icmpv6 | idpr-cmtp | igmp | ipencap | ipip | ipsec-ah | ipsec-esp | ipv6 | ipv6-frag | ipv6-nonxt | ipv6-opts | ipv6-route | iso-tp4 | l2tp | ospf | pim | pup | rdp | rspf | rsvp | st | tcp | udp | vmtp | vrrp | xns-idp | xtp) |
IP protocol (only if MAC protocol is set to IPv4)
jump-target (name) | If action=jump specified, then specifies the user-defined firewall chain to process the packet |
limit (integer/time,integer) |
Restricts packet match rate to a given limit.
log-prefix (text) | Defines the prefix to be printed before the logging information |
mac-protocol (802.2 | arp | ip | ipv6 | ipx | length | mpls-multicast | mpls-unicast | pppoe | pppoe-discovery | rarp | vlan or integer: 0..65535 decimal format or 0x0000-0xffff hex format) | Ethernet payload type (MAC-level protocol)
out-bridge (name) | Outgoing bridge interface |
out-interface (name) | Interface that the packet is leaving the bridge through |
packet-mark (name) | Match packets with certain packet mark |
packet-type (broadcast | host | multicast | other-host) |
MAC frame type:
src-address (IP address; default: ) | Source IP address (only if MAC protocol is set to IPv4) |
src-mac-address (MAC address; default: ) | Source MAC address |
src-port (integer 0..65535) | Source port number or range (only for TCP or UDP protocols) |
stp-flags (topology-change | topology-change-ack) |
The BPDU (Bridge Protocol Data Unit) flags. Bridge exchange configuration messages named BPDU periodically for preventing loops
stp-forward-delay (time 0..65535) | Forward delay timer |
stp-hello-time (time 0..65535) | STP hello packets time |
stp-max-age (time 0..65535) | Maximal STP message age |
stp-msg-age (time 0..65535) | STP message age |
stp-port (integer 0..65535) | STP port identifier |
stp-root-address (MAC address) | Root bridge MAC address |
stp-root-cost (integer 0..65535) | Root bridge cost |
stp-root-priority (integer 0..65535) | Root bridge priority |
stp-sender-address (MAC address) | STP message sender MAC address |
stp-sender-priority (integer 0..65535) | STP sender priority |
stp-type (config | tcn) |
The BPDU type:
vlan-encap (802.2 | arp | ip | ipv6 | ipx | length | mpls-multicast | mpls-unicast | pppoe | pppoe-discovery | rarp | vlan or integer: 0..65535 decimal format or 0x0000-0xffff hex format) | the MAC protocol type encapsulated in the VLAN frame |
vlan-id (integer 0..4095) | VLAN identifier field |
vlan-priority (integer 0..7) | The user priority field |
- STP matchers are only valid if destination MAC address is 01:80:C2:00:00:00/FF:FF:FF:FF:FF:FF (Bridge Group address), also
should be enabled.
- ARP matchers are only valid if mac-protocol is
- VLAN matchers are only valid for
ethernet protocol
- IP-related matchers are only valid if mac-protocol is set as
- 802.3 matchers are only consulted if the actual frame is compliant with IEEE 802.2 and IEEE 802.3 standards (note: it is not the industry-standard Ethernet frame format used in most networks worldwide!). These matchers are ignored for other packets.
Bridge Packet Filter
Sub-menu: /interface bridge filter
This section describes bridge packet filter specific filtering options, that are specific to '/interface bridge filter'
Property | Description |
action (accept | drop | jump | log | mark-packet | passthrough | return | set-priority) |
Bridge NAT
Sub-menu: /interface bridge nat
This section describes bridge NAT options, that are specific to '/interface bridge nat'
Property | Description |
action (accept | drop | jump | mark-packet | redirect | set-priority | arp-reply | dst-nat | log | passthrough | return | src-nat) |
to-arp-reply-mac-address (MAC address) | Source MAC address to put in Ethernet frame and ARP payload, when action=arp-reply is selected |
to-dst-mac-address (MAC address) | Destination MAC address to put in Ethernet frames, when action=dst-nat is selected |
to-src-mac-address (MAC address) | Source MAC address to put in Ethernet frames, when action=src-nat is selected |
[ Top | Back to Content ]


text:
How to Replace a Social Security Card in
Ellisville, Mississippi
Online-Application.org is professional filing agency that assists with application preparation for new or replacement social security cards. Our easy to use system allows you to complete the SS-5 form with confidence and ease. Save time and money allowing us to accurately prepare your forms from the comfort of your home. We are not affiliated with any government agency. We work for you directly!
You can obtain free assistance and forms by directly contacting the SSA (Social Security Administration).We work directly for you and include a Ebook, step by step instructions, and extended customer service.
It's just one small blue, delicate piece of paper — but a lost or stolen Social Security card can create a lot of emotional and financial distress. If your card is missing, it's imperative you take action immediately. Your card displays both your full name and Social Security number, and a criminal lurking in the shadows can wreak mayhem on your finances with just these two bits of information.
A lost or stolen Mississippi, MS and Ellisville Social Security card is all someone needs to open bank accounts, file bogus tax returns, acquire healthcare under your name, and much, much more. Suffice it to say, you should place your card in a safe place to stop accidental loss or theft.
However, things happen, even when we take the safest of precautions. If your card does go missing, here's what you need to do.
Two measures you MUST take if you've lost or misplaced your Social Security card
The single most important thing you can do is not panic. Take a deep breath and concentrate on what you can manage — like taking the appropriate measures listed below.
If you find out your Social Security card is lost, your initial actions should include taking steps to safeguard your finances. Thereafter, you can order your Mississippi, MS and Ellisville Social Security card replacement.
1: Protect Your Finances
Begin by calling the three major credit bureaus and requesting them to put a fraud alert on your file. The bureau you contacted will contact the other two and alerts will be placed with those agencies too.
Equifax: (800) 525-6285
Experian:(888) 397-3742
TransUnion: (800) 680-7289
Afterward, request a copy of your credit report from each of the three credit reporting bureaus to ensure there's nothing dubious listed.
If you've previously pulled your credit report to check it in the last year, you can still receive a copy — and you should, to investigate for fraud after dealing with a lost Mississippi, MS and Ellisville Social Security card.
Lastly, report your loss to the Federal Trade Commission at www.identitytheft.gov . They'll aid you in constructing an action plan to decide your next steps after taking the steps listed here.
2: Get a Social Security Card Replacement
Now that you've completed the primary steps to start protecting yourself financially, you can request a Mississippi, MS and Ellisville Social Security card replacement. Don't stress: it's actually very simple to get a replacement for a lost Social Security card.
In addition to preventing identity theft, securing a replacement Social Security card is often needed for important activities such as:
1. Going to the Doctor
Generally, when you go to a doctor's office, you will be asked to provide your social security card. Doctor's offices use your social security number both for billing and insurance purposes, and to ensure that your medical information is not breached by unauthorized personnel.
2. Obtaining Employment
Nearly all employers will request you provide your Social Security card. Employers must use your social security number for wage reporting on W-2 forms. Additionally, your employer may use your social security number to confirm that you are able to legally work inside the U.S.
3. Using a Credit Card
If you are considering applying for a credit card, you will need to provide your card issuer with your social security number as well. This enables creditors to certify your credit worthiness.
4. Getting an Education
Colleges and Universities may also request your social security card. This aids them in determining if you are eligible to attend school in the U.S. and that you are indeed who you claim to be.
5. Opening a Bank Account
If you want to open an account from a financial institution, you'll most likely be asked to furnish your social security card. Banks use the cards for a multitude of reasons, including confirming your identity in the event you forget your account number and substantiate your credit worthiness. Banks also need your social security number to report the interest your account accumulates to the Internal Revenue Service.
How easy is it to secure a new Mississippi, MS and Ellisville
Social Security card? It's as simple as 1, 2, 3!
Give your application to your local Social Security Office
After completing an SS-5 and assembling your essential documents you'll need to submit them to your local Social Security Administration Office. This can be accomplished by either: Delivering documents in person or by sending documents via mail.
The good news is, the process is simple and quite rapid. It usually takes approximately 14 days from the time you disclose the loss to secure a new Mississippi, MS and Ellisville Social Security card. And to top it all off, replacing a lost or stolen Social Security card is free.
Note: If you are submitting this application under another person's name, you will need to present evidence connecting you to this person. You can replace a lost or stolen Social Security card by beginning with a visit online, a trip to a Mississippi, MS and Ellisville Social Security office or a phone call.
If you go to your local Social Security office, you'll need to bring identification — notably:
- A U.S. driver's license
- A state-issued non-driver identification card, or
- A U.S. Passport
For a streamlined application process for all 3 of the steps outlined above click here.
Note the Social Security Administration dictates that all documents submitted to replace a stolen or misplaced Social Security card "must be either originals or copies certified by the issuing agency." The agency "cannot accept photocopies or notarized copies of documents."
Securing a replacement Mississippi, MS and Ellisville Social Security card is only part of process.
Here are various other steps we recommend taking when your Social Security card goes missing.
Step 1. Initiate a fraud alert
This can be done by simply contacting one of the major 3 credit-reporting agencies. Upon requesting a fraud alert, the credit reporting agency will reach out to the other two agencies to advise them too.
Here's the contact info for each agency.
Equifax: (800) 525-6285
Experian:(888) 397-3742
TransUnion: (800) 680-7289
Step 2. Examine your financial accounts and credit reports
Examine your credit card statements for suspicious activity and review your credit reports. "You are given one free credit report (from each agency) each year," Campbell says — and you can get it at AnnualCreditReport.com. "Carefully review your report for any activity you did not authorize and report any fraudulent or inaccurate information to creditors."
Step 3. Inform the IRS
If your Social Security card goes missing, it's imperative to also inform the Internal Revenue Service. This can thwart criminals from filing a tax return under your name. The IRS has a beneficial website page on the topic, "Identity Protection: Prevention, Detection, and Victim Assistance," that profiles the reporting procedure.
Step 4. File a report with the FTC
To bolster identity theft protection, file a report with the Federal Trade Commission, Campbell says. "The FTC collects complaints about identity theft from those whose identities have been stolen," she explains.
Contact the FTC at 1-877-438-4338.
Step 5. File a police report
Next, it's wise to report the stolen or lost Social Security card to your local Mississippi, MS and Ellisville police department. When you visit your local police station, deliver the proper paperwork, comprising a copy of your FTC Identity Theft Affidavit and any additional evidence of the theft. Fill out a report about the event and ask the police for a copy.
Swiftness is key when your Mississippi, MS and Ellisville Social Security card is lost or stolen. Rectify the situation by briefing the essential agencies, protecting your credit, and keeping I.D. thieves at a distance by obtaining a new Social Security card at once.

subset: commoncrawl


text:
Broadway magic? A new play is in the works for Broadway, set on the rivalry and friendship between NBA legends Magic Johnson and Larry Bird. The play is in its casting phase right now, which The Wall Street Journal noted was a blessing for the vertically-blessed. | And if you like your hardwood stories with a little bit of dance and song, Lysistrata Jones, a musical now in previews, opens Dec. 14.
Creative hunger. We're in love with the Museum of Communication in Berlin and their current food and fashion exhibit. Move over, Gaga! This fella is donning some carb-inspired, pasta-and-ravioli threads. Yum.
High society. New York's famed High Line park in Chelsea now has its own book, High Line: The Inside Story of New York City's Park in the Sky. On Wednesday, Nov. 30, Coach is hosting a release party for the book along with New York magazine at the Coach store in Midtown Manhattan.
short(er) balls: Both Caroline Wozniacki and Maria Sharapova voiced their want for the WTA's Season Ending Championships to move to London's O2 Arena to join the men. The feasibility of such a thing happening? At least a few years off with contracts in place and the events still three weeks apart. | On USA Today, Bethanie Mattek-Sands writes of her improved shoulder, taking care of her dog at home and the first-ever tennis camp she's hosting in Arizona next month. | The only golf and tennis shop in downtown D.C., Drilling Tennis & Golf, is set to close after over 30 years in business. | Beware, Martina Hingis! Tory Burch says she plans to eventually design yoga, tennis and golf lines for women. | IMG stalwart Teddy Forstmann, "one of the most powerful men in sports, fashion and media," according to The New York Post, died yesterday at the age of 71. He had brain cancer. | Growing in popularity in Australia? That'd be polo. | The world's largest jacket? Half the size of a tennis court, y'all!
(johnson/bird screengrab via official show website; museum photo via fox news; jacket image via world records academy)


text:
Halloween by VanjaShow a peek of skin with your own customized cut-out one-piece swimsuit! Our swimsuits are fully customizable from the front to the back and the straps as well so you let your inner designer run free and create a piece that will be sure to wow everyone this summer! Made from 90% Polyester, 10% Spandex Available in XS, S, M, L, XL, 2XL and 3XL Swimsuits are padded with an inner lining Swimsuit is packed in a transparent plastic bag Our editing software makes designing simple and easy Machine wash Designs imprinted using an advance heat sublimation technique; will not fade in water All swimwear comes with hygienic liners Attention: Due to bleeding and fabric stretch, the previewed image is only an approximated display of the final product.
If you order more than 50 pcs items (can be combined), please click here to contact us for whole price quotation, please include the SKU# and the quantity you want for each of them. For order less than 50 pcs, please order directly from our website.


text:
This article contains technical information about implementation of different categories of types (Value Types, Reference Types, Delegates, etc) in Microsoft CLR 2.0 (hereafter called as CLR). The concepts that are presented in this article are based on my analysis and study of type behavior in .NET using Son Of Strike (SOS) debugging extensions for VS.NET 2005 and the C# compiler. These concepts are also discussed in different MSDN blogs, MSDN articles and books. However, these forms are often in the context of a broader topic where finer and important points are not easily visible. I created this article to provide a single point of reference for these finer and important points about the inner workings of CLR with regards to types.
This article assumes that the readers have a working knowledge on a different category of types in .NET. Also this article do not discuss how to create and use different category of types, rather it progresses by examining the implementation details of different aspects of a different category of types in CLR. Initially I created this content as a document for my reference, but felt like publishing it as an artcile so that it may of be of some benefit to the .NET community. As such I would be very happy to receive any comments and feedback to improve the content of this article.
In .NET there are two main classifications of types and every type is derived from a Root Reference Type named System.Object (directly or indirectly through another base type).
Apart from simple differences on whether the instances of these types are allocated on stack or heap there are core internal design differences in the definition, behavior and instances of these types. Compilers and CLR together creates and maintain differentiation between a Value Type and a Reference Type during compile time and runtime. Understanding how CLR implements these types and how it works with these types will allow developers to design better .NET applications.
Value Types are allocated on stack. This is done to primarily reduce the contention on GC heap for types that simply represent basic data items. The contention could be due to heavy allocations, GC cycles and dynamic memory that need to be requested from the OS. This in turn will make the performance of using Value Types acceptable and efficient. Reference Types are allocated on GC Heap.
The instance of a Value Type contains JUST the values of its fields. Whereas the instance of a Reference Type contains additional baggage to deal with GC, Synchronization, AppDomain identity and Type information. This extra baggage adds 8 bytes to every instance of a Reference Type. The variable referring to an instance of Value Type represents the starting address of the Value Type instance allocated on the stack. The address of a local variable representing a Value Type instance is called a Managed Pointer and is normally used for reference parameters on the stack.
The variable referring to an instance of a Reference Type is called Object Reference and is a pointer to the starting address of Reference Type instance + 4 bytes. The starting address of any Reference Type instance is a 4 byte value called sync block address and points to a location in a process-wide table that contains structures used for synchronizing access to instances of Reference Types. The next 4 bytes contains the address of a memory (AppDomain specific) that contains a structure holding the Method Table of the Reference Type for which the object is instantiated or points to. This Method Table inturn contains a reference to another structure, which holds the Runtime Type Information of the corresponding Reference Type.
Presence of the pointer to the type's Method Table (and inturn the type's RTTI) in their instance is what makes Reference Types self describing types. Programs and CLR can discover information about the type of a Reference Type instance and can be used in several runtime facilities, like type casting, polymorphism, reflection, etc. Value Type instances on the other hand, due to lack of pointer to the type's Method Table in their instance, are simple chunks of memory without any clue to anyone about what that memory is. For this reason Value Types are NOT self describing types.
The figures below show the memory layout of Value Type and Reference Type instances.
Instance of a Value Type is created when it is declared. There is NO default constructor for Value Type. During instantiation, all the fields of a Value Type are initialized to either 0 (Value Type field) or null (Reference Type field). Ideally a Value Type instance fields should be used or accessed after instantiating the Value Type using new operator. But technically it is not required as the fields are already zeroed out by CLR during declaration of the Value Type instance. But languages like C# will NOT allow programs to use or access Value Type instance fields until they are set explicitly to some value or the instance of the Value Type is created using new operator. This behavior is for saving additional constructor calls for simple Value Types that are heavily used in applications. Value Types can have parameter constructors, which can be explicitly called to create an instance of a Value Type. In this case the parameter constructor has to initialize all the fields of its Value Type.
Reference Types on the other hand MUST be allocated using new operator and should have a default constructor or parameter constructor. While creating instance of a Reference Type, CLR will first initialize all the fields of the Reference Type and then will call into either default or parameter constructor based on the constructor specified in the new operator.
CLR's Garbage Collector uses the above variables, also called GC roots, to track down the Object References during garbage collection phase. Any Reference Type instance located in GC heap, for which there is no Object Reference in any of the above variable types (except for the FReachable Queue), is considered a candidate for garbage collection and is removed from GC heap. If the Reference Type instance being removed implements the Finalize method, then the Object Reference is put on FReachable Queue for calling the Finalize method by a separate Finalizer thread. Once the Finalizer thread completes Finalize method call on an Object Reference, the corresponding Reference Type instance is removed from the GC heap.
As discussed in the Instantiation section, Value Types cannot and do not have default constructor. They can have parameter constructors and need to be explicitly called using new operator. Constructors either for Value Types or Reference Types are just another instance method of a type. They are implicitly used by compilers to initialize the type fields and do some initialization operations. But compilers do not allow programs to explicitly call constructors on the type variable after it is instantiated. But technically a constructor of a type can be called after it is instantiated (i.e can be called several times in the lifetime of a type instance). This can be done by cheating compilers and writing some IL code. One can disassemble the assembly into IL using ILDASM, modify the IL and include calls to constructor of a type instance and reassemble the assembly using ILASM. However, this is not required and if initialization of the same type instance is required multiple times in its lifetime, then developers can define a public method on the Type that can do the same Job as its constructor.
The difference between a Value Type constructor and Reference Type constructor is that, a Reference Type constructor should always call the default constructor of its base class. This is because the CLR will not do it automatically and it is the responsibility of the Reference Type to do it. This is NOT required for Value Type for obvious reasons because Value Type does not have any default constructor and it cannot act as a base class. For Reference Type, compilers (like C#) automatically insert the calls to base type constructor from within the derived type constructor, while compiling the source to MSIL.
Value Types are derived from a special type named System.ValueType, which inturn is derived from System.Object. Any type derived from System.ValueType is treated as Value Type by CLR. CLR uses this knowledge to work on the type's instances as discussed in the above sections and following sections. Reference Types do not have System.ValueType in their base class hierarchy. In fact, some compilers will not allow any type to derive from System.ValueType directly. Compilers always provide an indirect enforceable way to specify a type as being derived from System.ValueType and enforce certain definition rules on those types. Also based on this enforceable language rule, compilers will generate MSIL code that is appropriate to Value Types. This is required because, while coding at MSIL level (or in ILASM), any type can be derived from System.ValueType and it can even contain default constructor and incorrect MSIL instructions, which should NOT be present (because a default constructor is never called) for a Value Type.
Value Types cannot be used as base types for other types. Definitely a Value Type cannot be a base class for a Reference Type as the Value Type do not have default constructor, its memory layout is different than that of a Reference Type, etc. But why a Value Type cannot be a base class for another Value Type? The answer lies in the memory layout of the Value Type instances. .NET uses Method Table to achieve runtime polymorphism (virtual method dispatch). Since the instance of a Value Type does not contain Method Table, CLR cannot use it to correctly dispatch the virtual method calls (Method dispatch internals are discussed in the following sections). Due to this .NET cannot provide runtime polymorphism with Value Types. And without runtime polymorphism, inheritance is incomplete from an Object Oriented Design perspective. So all the compilers including ILASM will mark any Type derived from System.ValueType as sealed. And any type that is sealed CANNOT be used as a base and this restriction is enforced by CLR during runtime while loading a type. If CLR finds a type being loaded has a base type that is marked as sealed, it will stop loading the derived type and throws a System.TypeLoadException exception
System.ValueType overrides the Equals and GetHashCode virtual methods of its base type System.Object. Any type that is derived from System.ValueType that uses Equals for comparison of its instances, need to override these two methods to improve performance. This is because the Equals method uses reflection for comparison of two Value Type instances if it cannot compare the fields of the Value Type instances at bit level. To eliminate reflection and its associated performance penalty during equality comparison of two Value Type instances, it is better for a structure (derived type of a System.ValueType) to override these methods and perform custom equality check and hash code generation.
For Reference Type instances, which are directly or indirectly derived from System.Object, the Equals and GetHashCode methods are implemented in System.Object and work based on the Object Reference value, rather than the actual field values of the type instance.
Most commonly these two methods are overridden together so that two instances of the Value Type can be compared equal either using Equals or using GetHashCode. Another reason for considering overriding of ToString, Equals and GetHashCode methods of System.Object for a user defined Value Type (struct) is that, without overriding if these methods are called using Value Type variable, CLR has to box the Value Type instance and then calls the method on the boxed instance of the Value Type.
Value Type instance is always copied by value into another variable of the same Value Type. This copy could occur while passing a variable of a Value Type as argument to a method parameter expecting the same Value Type. This copy could also occur while assigning (NOT initializing during instantiation) a Value Type variable to another variable of the same Value Type. A Value Type may contain fields that are all primitive (cannot be broken down further) data types, Value Types and/or Reference Types. If a field is a primitive type or Value Type its value is copied as it is. If a field is a Reference Type the Object Reference present in the field is copied over to the corresponding field of target Value Type instance
The 'this' pointer available to the instance methods of a Value Type points to the address of the first instance field of the type's instance memory. So if an instance field is accessed within an instance method, it would be accessed directly from the address pointed to by the 'this' pointer + the offset of the field as layed out by the CLR. This field offset is determined by the CLR during loading of the type and is used for all the instances of the type through the lifetime of the AppDomain.
The 'this' pointer available to the instance methods of a Reference Type points to the address of the Method Table information block of the type's instance memory. So if an instance field is accessed within an instance method, it would be accessed from the address pointed to by the 'this' pointer + 4 bytes + the offset of the field as layed out by the CLR. Adding a value of 4 brings the pointer to the first instance field of the instance. This field offset is determined by the CLR during loading of the type and is used for all the instances of the type through the lifetime of the AppDomain
A Value Type instance on stack without any Method Table is called unboxed value of the Value Type instance. If this value has to be assigned to a System.Object variable, then we need an instance of the Value Type in memory that has Method Table in its memory layout. This is required because System.Object is a Reference Type with Virtual methods (Equals, GetHashCode and ToString). So any calls to those methods require a valid non-null Object Reference. But just hang on. Let us say that a program overrides the GetHashCode method and creates its custom one using the field data of the Value Type. Now within the GetHashCode override method if any type's fields are used they are accessed using the starting address of the 'this' pointer. But if we do boxing and create an Object Reference for the Value Type instance and call GetHashCode method using that, then the starting address of the Object Reference, which is the starting address of the Method Table is passed as this pointer into the overridden method. This will cause problems during method execution as the method is expecting its field value instead of Method Table. To avoid this when a Value Type instance is boxed CLR makes sure that the virtual methods called on the System.Object variable will have the starting address of the first field item in the type instance. To this effect CLR takes care of passing correct starting address, either Object Reference or Managed Pointer, based on the type instance, which is either direct Value Type instance, boxed Value Type instance or direct Reference Type instance.
Boxing involves creating an Object Reference pointing to the heap based memory location, created to hold the Value Type data (fields), copying the data from the Value Type instance to the field portion of the type's instance. Unboxing involves creating a stack based instance of the type and copying the field data from the Object Reference to it. Unboxing happens when a System.Object variable is type casted to a Value Type instance
Non Virtual instance methods dispatched in both Value Types and Reference Types are the same. It is done using the call IL instruction, which requires that the type's instance pointer, 'this' pointer, be available on the stack as first method argument, before any other arguments of the method. The JIT while compiling the method's call site will burn the address of the method body (code) present in the instance method slot, into the machine code. This method address is taken from the type's Method Table structure.
As discussed in Memory Layout section, the Object Reference points to a 4 byte address at the starting of the type instance, which contains the address of type's Method Table. The Method Table contains the following information apart from other information.
CLR does not check the validity of the instance pointer while making non virtual instance method calls. So practically it is possible to call an instance method using a type variable that is not yet instantiated or a type variable having null Object Reference (you can try this by modifying IL of an assembly). But remember if the method being called using a null Object Reference contains access to the type's fields or calls to other methods that access type's fields then a System.NullReference exception will be thrown by CLR while executing such instructions within the method. This is because CLR checks for the validity of the Object Reference while accessing instance fields. This is again because fields are present in the memory location allocated for the type's instance, and for a null instance, no memory is allocated.
Allowing method calls on null Object References is considered dangerous and unpredictable. For this reason many .NET compilers like C# will emit callvirt IL instruction even while calling non virtual instance methods. Callvirt IL instruction will instruct CLR to generate machine code that first checks for the validity of the Object Reference. If the Object Reference is null, the generated machine code will raise an exception, else the method is called. Remember, using callvirt by C# for even non virtual method calls will NOT have performance penalty. This is because callvirt on a non virtual instance method has only one additional instruction of comparing the Object Reference with null apart from an instruction that directly jumps to the method address for method execution. In case of callvirt being used on virtual instance methods, there are additional instructions trying to figure out the method address based on the type that is actually pointed to by the Object Reference. Virtual method dispatch is discussed in detail in the next section
CLR coverts the call IL instruction into the following machine code (Psuedocode)
Shown below are the close equivalent of IA32 instructions for the above psuedocode.
mov ecx, esi ; assuming esi has Object Reference call dword ptr ds:[567889h] ; call into the address where method code resides
Virtual methods can only be instance methods. This is because the virtual method dispatch mechanism is used to call a method based on the type of the object pointed to by the variable, instead of the type of the variable itself. Since we need the object of a type, it makes sense to have virtual method dispatch mechanism on instance methods.
In case of Value Types, virtual methods dispatch (call) similar in behavior to non virtual instance methods. This is because Value Types cannot be inherited and as such there is no need (enforced by CLR) and no way (enforced by compilers like C#) to define polymorphic behavior (virtual methods) on Value Types. So, languages like C# do not allow Value Types (struct) to define virtual methods. Also callvirt IL instruction is not required while calling methods on Value Types, because instance memory is created and initialized for the Value Type variable at the declaration instruction itself. So there is no point of checking the Value Type variable for null before calling methods using it. But MSIL allows a method definition to be virtual and be called using callvirt IL instruction. But nevertheless CLR, while generating the machine code, will optimize it to a regular instance method call.
The virtual dispatch mechanism is applicable to a Value Type only when the virtual methods from System.Object type are called using the Value Type variable. In this case if a System.Object method which is NOT overriden in Value Type is called, CLR will box the Value Type instance before calling the method. If a System.Object method is overriden in a Value Type and is called using the Value Type variable, then CLR calls the method directly without any boxing and virtual dispatch. This difference in behavior during runtime is achieved by CLR using an IL instruction named constrained <Type Token>. The constrained IL instruction checks if the type represented by the token is a Value Type. If it is a Value Type and if the Value Type implements the method being called by following callvirt IL instruction, then it simply emits a direct call instruction to the method. If the Value Type does not implement the method being called by following callvirt IL instruction, then it will box the Value Type instance and emits a virtual call to the method.
In case of Reference Types virtual methods are dispatched based on the corresponding virtual method address present in the Method Table of the target object pointed to by the type variable.
CLR converts callvirt IL instruction into following machine code (Psuedocode) for virtual method calls.
mov ecx, esi ; move the Object Reference to ecx cmp dword ptr [ecx], ecx ; try de-referencing ecx. If ecx is null, CLR will catch the memory access violation and will convert that to System.NullReferenceException mov eax, dword ptr [ecx] ; move the Method Table structure address of the type to eax call dword ptr [eax + 40h] ; call into address where method code resides
Remember the memory layout of the Method Table structure from section Non Virtual Instance Method Dispatch. The method slots where the inherited virtual method addresses are stored are NOT duplicated if the virtual methods are overridden by the derived types. Instead if a virtual method is overridden in the derived class, its slot in the top most parent type is replaced by the address of the corresponding virtual method overridden in the bottom most derived type. This technique allows CLR to maintain the same offset for a method in the Method Table structure based on the method token.
CLR converts callvirt IL instruction into following machine code (Psuedocode) for non virtual instance method calls.
mov ecx, esi ; move the Object Reference to ecx cmp dword ptr [ecx], ecx ; try de-referencing ecx. If ecx is null, CLR will catch the memory access violation and will convert that to System.NullReferenceException call dword ptr ds:[567889h] ; call into the address where method code resides
Interface based method dispatch happens when a method is called on a type instance using a variable of an interface type, where the interface is implemented by the type. Since any type can implement multiple interfaces in any order, the Method Table of a type instance is required while calling methods on it using a variable of one of the interfaces that the type implements. Since a Value Type instance does not have Method Table, it has to be first boxed before assigning it to an interface variable, so that any calls on the interface variable can use the Method Table of the Value Type from the boxed instance (Object Reference).
Once boxed, interface-based method dispatch on a boxed Value Type instance and a reference Type instance is same. callvirt IL instruction is used to dispatch interface method calls. CLR converts callvirt IL instruction into following machine code (Psuedocode).
mov ecx, esi ; move the Object Reference to ecx cmp dword ptr [ecx], ecx ; try de-referencing ecx. If ecx is null, CLR will catch the memory access violation and will convert that to System.NullReferenceException mov eax, dword ptr [ecx] ; move the Method Table structure address of the type to eax mov eax, dword ptr [eax + 0ch] ; move the address of starting IOT slot for this type into eax ... ; find the offset (02h) of the interface starting from eax mov eax, dword ptr [eax + 02h] ; move the address of IMT starting slot for the interface into eax call dword ptr [eax + 3h] ; call into address where method code resides
JIT does some optimizations for interface based dispatch. If the same type is being used for method dispatch at a given call site, JIT can identify it and optimize the above 8 steps to just a direct jump to the method address. But this involves overhead of maintaining a call counter, checking for specific number of calls, storing the current type's Method Table address, storing the current type's method address, comparing the current type's Method Table address with incoming type's Method Table address, etc. CLR 2.0 uses this technique to dramatically improve the performance of interface based method calls. But this may also have severe performance penalty in case the call site is being provided with different type instances very frequently.
Delegate is a special kind of Reference Type. Each delegate represents a UDT (class). The signature of the Invoke method of a delegate UDT type should match the signature of the method that the delegate is used to call. The bodies of the Invoke method of a delegate UDT including its asynchronous version BeginInvoke method are generated at runtime by CLR during instantiation of the delegate UDT. Delegate UDT constructor takes two parameters, the target object and the address of the target method (address where the method code resides) to invoke on the target object. Target object could be null in which case the method is considered static and is invoked based on the type of the target object variable. Target object can be a Reference Type instance or a Value Type instance. In case of Value Type instance, it needs to be boxed before passing it on to the delegate instance.
But in Managed world how can we get the address of the target method? MSIL has two opcodes to load the address of a type's method onto the stack. These are ldvirtftn and ldftn. ldftn will load the method address on to the stack from a method token. The type of a method can be retrieved from a method token, which CLR uses to lookup the Method Table of the type and will get the address of the method from the Method Table of the type's Method Table. ldvirtftn is used to load the address of a virtual method. ldvirtftn requires an Object Reference on the stack, which it uses to get the Method Table and then figure out the method address based on the method toke. Compilers (like C#) uses one of these two IL instructions when a method name is specified as argument to a delegate UDT constructor, based on whether the method is a virtual, non virtual or static method. This process of retrieving and storing the method address within a delegate instance is called delegate binding. This is the costly operation in the whole process of executing a method using a delegate instance. Once a method is bound to a delegate instance, CLR writes up the Invoke method body, which is very efficient and has following machine code (Psuedocode) instructions.
mov ecx, [ecx + 0ch] ; ecx contains the delegate instance address and 12 bytes within the delegate instance contains target Object Reference call dword ptr ds:[567889h] ; call into the address where method code resides
Also, Invoke method of a Delegate type created by CLR at runtime uses jmp IL instruction to jump to the target method. jmp instruction simply jumps from the current method to the destination method without clearing up the stack. So the arguments passed at call site are available to the method being jumped to. The return address on the stack would be the return address of the original caller of the Invoke method. So when target method completes, it directly returns to the caller by passing the Invoke method. So once bound, performance of a delegate based method dispatch almost equals the performance of a virtual method call.
Delegate instances can be combined together to form a chain, where the last added instance will at the head of the chain. When the delegate instance at the head of a delegate chain is invoked, it passes on the invocation to next delegate instance in the chain. This passing continues until there is no next delegate instance. The delegate based method call starts at this final delegate instance (the one that is added first to the chain and is last in the chain) and comes back until the head of the delegate instance calls the method it wraps.
While executing a delegate chain the return value and the output parameters values will be ones that are set by the last delegate handler added to the chain (And first delegate in the chain, the head of the chain).
Enumeration is a special category of Value Type. Each Enumeration type contains a single instance field to hold the value of the enumeration and is of the same data type as that of the enumeration (By default, System.Int32 in C#). Each Enumeration also should contain one or more static literal values representing the named data constants exposed by the Enumeration type. CLR allows explicit conversion between the named data constants of an Enumeration type and the underlying data type of the Enumeration. So, if an Enumeration is of type System.Int32, then one of the named data constants of the Enumeration Type can be assigned to a variable type System.Int32 using type casting and vice versa. The vice versa business is a dangerous one and need to be used judiciously. This is because, CLR does not throw any exception if an integer value that does not belong to one of the data constants exposed by the Enumeration type is assigned to a Enumeration variable using explicit type casting. Rather it simply assigns it to the internal instance member of the Enumeration instance. After this casting, the Enumeration instance contains invalid value, which is only a logical error that may cause unpredictable results in the program.
The named data constants used by Enumeration types, when assigned to a variable or used in expressions (like switch case) are directly replaced by the compilers with the actual constant value during compile time. This is because MSIL and thus CLR have no mechanism to load a constant/default values for a field during runtime. All the constant values are stored in metadata against the corresponding field. Compilers use this value stored in metadata and replace the name of the constant with the actual value during compilation. This has an interesting side effect if you are shipping assemblies with modified enumeration data constants and the client application is run without recompiling against the modified assembly. In such cases client application will have a value of X, hard coded in its code for a named enumeration data constant, where as the same value X may mean a different named data constant in the modified assembly. This will lead to unpredictable behavior of the programs.
Arrays are special category of Reference Type. For each distinct array of Value Type (including primitive types like int, byte, etc) defined in a program, CLR creates and maintains a Reference Type at runtime, which will be derived from System.Array Reference Type. This synthesized array type has a constructor that takes the size of the array as argument for single dimensional array or jagged array and dimension sizes for multidimensional array. This constructor is exposed in different ways to the programs by .NET programming languages. For instance C# exposes this constructor using typical C/C++ array index syntax, int[] i = new int[10];. For all arrays of Reference Types CLR creates and maintains a single Reference Type named System.Object[] at runtime, which will be derived from System.Array. This is because all the elements of a Reference Type array just hold the Object Reference, which is of same size and have same internal memory representation.
int[] i = new int[10];
Single dimensional and jagged array elements are directly accessed or modified from the memory location of the instance of the runtime array type based on their index. For this CLR provides a special IL instruction named ldelem and stelem, which retrieves and modifies an array element based on its index and the array Object Reference available on the stack. Whereas the multidimensional array elements are accessed or modified using method calls on the synthesized runtime type of the array type. This makes jagged arrays much faster than the multidimensional arrays and is recommended way of using arrays in case multiple dimensions are required. Jagged arrays are CLS compliant and are mistakenly documented as NOT CLS compliant. This fact is acknowledged in MSDN2.
A Generic type can be a open type where some or all of the Type Parameters are not yet replaced with a non-generic type or closed generic type. A Generic type can be a closed type where all of its Type Parameters are replaced with non-generic types or closed generic types. Only closded Generics types can be instantiated. The reason is obvious because there would be methods called on the type parameter variables within the methods of the Generic type. So without knowing the type of the variable CLR cannot instantiate a type for the variable. For each closed Generic Type that is supplied with a Value Type for a Type Parameter, CLR creates a new type during runtime and uses it for instantiations and other purposes. For all closed Generic Types of a given Generic Type that is supplied with a Reference Type, CLR creates one type where the Type Parameter for which a Reference Type is supplied, is replaced with a special type named System.__Canon. Let this type be named as Generic<T.System.__Canon>.
For each closed Generic Type of a given Generic Type, with a distinct Reference Type Parameter, CLR creates a distinct type with Type Parameter replaced with the supplied Reference Type. This Reference Type will be a dummy type to serve the type safety during passing around. This type's EEClass contains pointer to the EEClass structure of the type Generic<T.System.__Canon> CLR dispatches any method calls on the closed Generic Type instance using the Method Table of the Generic<T.System.__Canon> type. BTW, EEClass is a companion structure to Method Table and is created by CLR for each loaded type in the AppDomain. EEClass has all the type information for a given type. Method Table has a pointer to the EEClass.
public class DisplayClass : IDisplay { public void Display() { Console.WriteLine("From DisplayClass"); } } public struct DisplayStruct : IDisplay { public void Display() { Console.WriteLine("From DisplayStruct"); } } public class Test<T> where T : IDisplay { public T _field; public void Show(T temp) { temp.Display(); } } public static void Main(string[] args) { // Reference Type as Type Parameter // Test<DisplayClass> objTestClass = new Test<DisplayClass>; objTest.Show(new DisplayClass()); // Value Type as Type Parameter // Test<DisplayStruct> objTestStruct = new Test<DisplayStruct>; objTestStrucr.Show(new DisplayStruct()); }
When the above code is compiled using a C# compiler, it creates a type named Test`1<(Test.IDisplay) T), which acts as placeholder for the types that CLR would be creating during runtime. During runtime CLR will create a type named Test.Test`1[[Test.DisplayClass, ConsoleApplication5]] for the closed Generic Type Test<DisplayClass>. The prefix Test. is the namespace name and the name ConsoleApplication5 is the assembly name. This type is a empty type without any methods. All the methods that are defined in the open Generic Type Test<T> are defined in a class named Test.Test`1[[System.__Canon, mscorlib]].
When the method Show is called on the variable objTestClass as shown in the above code snippet, CLR at runtime will call into the Show method defined by the type Test.Test`1[[System.__Canon, mscorlib]]. This design on having all the method definitions of a closed Generic Type whose Type Parameter is a Reference Type, in a single type, will reduce code bloat. This design works because all the method calls on any Type Parameter variable inside a Generic Type is only through known interfaces or base class. So CLR need not re-write the method IL for each Reference Type provided as parameter. Also any arguments to methods or return values involving Type Parameters would all be Object References, which are memory layout wise and copy smeantics wise same for any Reference Type Parameter.
Whereas for the closed Generic Type Test<DisplayStruct> CLR creates a non-empty type named Test.Test`1[[Test.DisplayStruct, ConsoleApplication5]]. This type has the all the methods as defined in the open Generic Type Test<T>. Though method call behavior on the Type Parameters is same for Value Type Parameter and Reference Type Parameter, the copy semnatics and memory layout are different. So if a method in open Generic Type, Test<T>, is returning a Type Parameter variable then the method should return the exact Value Type instance. For this reason it is not possible to have a common base class for all closed Generic Types constructed from a open Generic Type, whose Type Parameter is a Value Type.
There could be scenario where a open Generic Type has multiple Type Parameters and the program creates closed Generic Types with mix of Reference Types and Value Types for the Type Parameters. In this case, CLR creates one base type for a set of closed Generic Types with same combination of Value Types and any combination of Reference Types for Type Parameters.
When the method Show calls the method Display using the Type Parameter variable (temp.Display() as shown in the above code snippet), C# emits a callvirt on the approriate interface method, callvirt instance void Test.IDisplay::Display() (or a callvirt on the base class method if the Type Parameter is provided with a base class constraint). The callvirt IL instruction emitted by C# is preceded with constrained IL instruction also. This is because C# does not know the type of the Type Parameter during compile time. constrained IL instruction will allow CLR to check the type of the Type Parameter variable at runtime and if it is a Reference Type, a virtual dispatch to the method is done. If the typeof the Type Parameter variable is a Value Type, the call is dispatched as explained in the Virtual Method Dispatch (Method Call) section.
callvirt instance void Test.IDisplay::Display()
Though the type of the Type Parameter is known during runtime CLR does not modify the IL of the method. This makes sense when a Type Parameter is a Reference Type because all the closed Generic Types with any Reference Type share the same method code for a method of the open Generic Type. But when a closed Generic Type is constructed using just Value Types, even then CLR doe not modify the IL of the closed Generic Type method to make NON-constrianed calls. This is one of the questions for which I do not have answer yet.
CLR handles the Generic Value Types similar to that of the Generic Reference Types, like using System.__Canon type, using constrained virtual method calls, etc.
This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.
A list of licenses authors might use can be found here
class Class1 { public void xx() { } } class Program : Class1 { static void Main(string[] args) { } }
!dumpmt -md 00153898 EEClass: 00151474 Module: 00152ea4 Name: ConsoleApplication24.Program mdToken: b1d44c0002000003 File: E:\c#\ConsoleApplication24\ConsoleApplication24\bin\Debug\ConsoleApplication24.exe BaseSize: 0xc ComponentSize: 0x0 Slots in VTable: 6 Number of IFaces in IFaceMap: 0 -------------------------------------- MethodDesc Table Entry MethodDesc JIT Name 530ba790 52e94cd8 PreJIT System.Object.ToString() 530be290 52e94ce0 PreJIT System.Object.Equals(System.Object) 530be1a0 52e94d00 PreJIT System.Object.GetHashCode() 531417b0 52e94d14 PreJIT System.Object.Finalize() 0015c038 0015388c NONE ConsoleApplication24.Program..ctor() 0015c030 0015387c JIT ConsoleApplication24.Program.Main(System.String[])
Entry MethodDesc JIT Name 0091c060 009131dc JIT MyClass.Method0() 0091c068 009131ec JIT MyClass.Method1() 0091c070 009131f8 JIT MyClass.Method2() 0091c078 00913204 JIT MyClass.Method3() 0091c080 00913210 NONE MyClass.Method4() 0091c088 00913220 JIT MyClass..ctor() 0091c090 0091322c JIT MyClass..cctor() 79286aa0 79104924 PreJIT System.Object.ToString() 79286ac0 7910492c PreJIT System.Object.Equals(System.Object) 79286b30 7910495c PreJIT System.Object.GetHashCode() 792f7410 79104980 PreJIT System.Object.Finalize()
public interface MyInterface1 { void Method1(); void Method2(); } public interface MyInterface2 { void Method2(); void Method3(); } class MyClass : MyInterface1, MyInterface2 { public static string str = "MyString"; public static uint ui = 0xAAAAAAAA; public static void Method0() { Console.WriteLine("Method0"); } public void Method1() { Console.WriteLine("Method1"); } public void Method2() { Console.WriteLine("Method2"); } public virtual void Method3() { Console.WriteLine("Method3"); } public void Method4() { Console.WriteLine("Method4"); } }
Class DoItMagic Interface iAct(Of T) Sub Act(ByVal param As T) End Interface Public Shared Sub exec(Of T)(ByVal target As iAct(Of T), ByVal param As T) target.Act(param) End Sub End Class
Class DoItTarget Implements DoItMagic.iAct(Of param1), DoItMagic.iAct(Of param2) Class param1 End Class Class param2 End Class Public Sub Act_param1(ByVal param As param1) Implements DoItMagic.iAct(Of param1).Act End Sub Public Sub Act_param2(ByVal param As param2) Implements DoItMagic.iAct(Of param2).Act End Sub End Class
Class DoItTest Public Shared Sub hitEverything(Of T, U As DoItMagic.iAct(Of T))(ByVal theList As List(Of U), ByVal theParam As T) For Each thing As U In theList DoItMagic.exec(Of T)(thing, theParam) Next End Sub Dim firstParam As DoItTarget.param1 Dim secondParam As DoItTarget.param2 Dim L As List(Of DoItTarget) Sub go() hitEverything(Of DoItTarget.param1, DoItTarget)(L, firstParam) hitEverything(Of DoItTarget.param2, DoItTarget)(L, secondParam) End Sub End Class
General News Suggestion Question Bug Answer Joke Praise Rant Admin
Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.


text:
Graduates of the associate degree nursing program at Pearl River Community College received their pins in a ceremony on May 8 in Poplarville. They are, front row from left, Allison Pigg of Picayune, Kimberly Rachford of Carriere, Ashley Reed of Hattiesburg, Ashley Robertson of Columbia, Christine Sanders of Poplarville, Keiva Smith of New Orleans, La.; Melanie S. Taylor of Nicholson, Stacy Vega of Poplarville, Hannah Walker of Petal, Kayla Wascom of Carriere; second row, Virginia Landry of Picayune, Lee Thatcher of Poplarville, Chassidy Martin and Megan Maximo, both of Picayune; Lori Hayes of Hattiesburg, Devin Mitchell of Picayune, Kimberly Mittelstaedt of Carriere, Ashton Necaise of Lumberton, Rebekah Nolan of Wiggins, Heather Owens of Biloxi, Jennifer Peel of Bay St. Louis; third row, Shasta Dubrel of Carriere, Brooke Eagle of Poplarville, Brittany Farris of Foxworth, Melanie Frierson of Picayune, Rachel Guidry of Slidell, La.; Jennifer Brittain of Carriere, Nicole Humphrey of Sumrall, Aliana Hunt of Pearlington, Megan Davis of Lumberton, Brittany Flathers of Sumrall, Courtney LaCoste of Kiln, Hayley Ladner of Poplarville, Brittany Ory of Kiln; fourth row, Hannah Barattini of Picayune, Leon Benson Jr. of Carriere, Alisha Bertrand of Poplarville, Matthew Betsayad of Picayune Aimee` Boyle of Lumberton, Michael McDonald of Hattiesburg, Emily Coker of Hattiesburg, William Courtney of Purvis, Tiffany Daniels of Pass Christian, Jeremy Kibodeaux and Bradley Williams, both of Hattiesburg; Shawna Dillard of Carriere and Allie Dreux of Pearl River, La.
PRCC Public Relations photo


text:
Mitt Romney has filed his tax returns — to the voters. And to no one's surprise, the former Massachusetts governor, private equity firm exec and GOP presidential contender makes a tidy sum.
NPR asked William Gale, co-director of the Brookings Institution's Urban-Brookings Tax Policy Center; Alan Viard, a resident scholar who specializes in federal tax and budget policy at the American Enterprise Institute; and Victor Fleischer, a professor of law specializing in tax at the University of Colorado Law School, to comment on the controversy surrounding Romney's income and the taxes he pays.
Q: How could Mitt Romney, a millionaire several times over, pay a tax rate lower than many middle-income Americans?
Viard: At the higher income range ... how much individual income tax you pay is heavily dependent on whether your income is long-term capital gains and qualified dividends on the one hand, or whether it's so-called ordinary income on the other hand. The statutory rate differential really tells the story; you have a 35 percent statutory rate on income [at the top] and a 15 percent statutory rate on long-term capital gains and qualified dividends.
Q: Does the middle class as a group bear the largest portion of the federal tax burden?
Gale: It depends on what you call the middle class. People who are in the 95th percentile think of themselves as the middle class. If you think of the middle class as the 30th to 95th percentile, you probably get that answer.
Fleischer: The very rich still end up contributing the most in federal income taxes. After all, they have most of the income, even if it is not always taxed at the highest rate.
Q: Why would Romney's effective tax rate be so much lower than other millionaire politicians?
Viard: If a person has a large portion of their income from long-term capital gains and qualified dividends, then their individual tax rate is going to be much lower than it would be for someone else in the same income bracket whose income is largely of the ordinary variety. If you look at the upper-income groups, I think there is a great disparity in that regard. The high-income levels are a really heterogeneous group — there are some whose income comes largely from wages; people in very high-paying jobs such as corporate executives, athletes and entertainers. That's going to be in the 35 percent bracket. Then there are others whose income is almost exclusively in capital gains in dividends and they're going to be getting that 15 percent rate.
Fleischer: Mr. Romney's average tax rate is about 14 percent because most of his income comes from something called carried interest. Carried interest is a percentage of profits that a fund manager receives as compensation for managing someone else's investments. What's unusual about the situation is that Mr. Romney isn't paying a low tax rate because he's sitting on investments that he made — lots of rich people do that. He's paying tax at a low rate because his labor income is taxed as if it were capital gain.
Gale: [Also] ... clearly Romney gave a significant amount to charitable organizations.
Q: Are there other special tax breaks available to someone in the highest income bracket that average Americans would not get?
Gale: The two obvious ways are exclusions and deductions. Exclusions never show up on the tax form to begin with. I'm guessing, just guessing, that that's big here. But, we don't know, because by virtue of them not being on the tax form, no information on them is provided when the tax form is released.
Fleischer: Carried interest is just one of the tax breaks that some rich people — in this case investment fund managers — can take advantage of. Other breaks include large retirement accounts, deferring income offshore, shielding business income in trusts, and avoiding payroll taxes on small-business income. For Mr. Romney, the biggest tax breaks are carried interest, taxed at 15 percent, and a huge IRA, which defers a lot of his income until later.
Copyright 2021 NPR. To see more, visit https://www.npr.org.


text:
Isaac M. Morehouse is policy programs director at the Institute for Humane Studies, a Fairfax, Va.-based organization that facilitates the academic development of college students with an interest in liberty. Morehouse was the Mackinac Center for Public Policy's first director of campus leadership, working for the Center from January 2007 through May 2009. During that time, he developed and coordinated on-campus free-market educational programs for Michigan college students.
Prior to working at the Center, Morehouse served as a Michigan House legislative aide for three years, finishing his time at the House as chief of staff for a state representative. Morehouse has also helped run a small business involving telecommunications hardware and cable installation.
Morehouse's nonprofit work includes co-founding an organization that trains students for humanitarian trips overseas and serving as president of the Kalamazoo County Taxpayers Association. He holds a master's degree in economics from the University of Detroit Mercy, and he received his bachelor's degree in political science from Western Michigan University.
Morehouse lives in Falls Church, Va., with his wife and son.


text:
Once admitted (or readmitted) to an MIT advanced degree program, a person becomes a student at the start of the term for which he or she was admitted. The person retains regular student status until graduation, unless the student withdraws, is required to withdraw, or fails to complete registration.
Each student is assigned to a departmental faculty member who serves as the student's graduate registration officer. The registration officer must approve the student's program as well as any subsequent changes.
Status of registration
Information and expectations regarding student registration
Retention of student status
Procedure for retaining status as a student
Medical report requirement
Requirements regarding the reporting of medical history to the Institute
Different ways a student can receive credit for subjects
Academic terms
Description of and instructions for registration for academic terms (Fall, Spring, Summer, Independent Activities Period)
Tuition and fees
Where to find information about tuition and fees