Switching. An Engineering Approach to Computer Networking

Switching

An Engineering Approach to Computer Networking

What is it all about?

■

■ How do we move traffic from one part of the network to another?_{How do we move traffic from one part of the network to another?}

■

■ Connect end-systems to switches, and switches to each otherConnect end-systems to switches, and switches to each other

■

■ Data arriving to an input port of a switch have to be moved to_{Data arriving to an input port of a switch have to be moved to} one or more of the output ports

Types of switching elements

■

■ Telephone switches_{Telephone switches}

◆

◆ _{switch samplesswitch samples}

■

■ Datagram routers_{Datagram routers}

◆

◆ _{switch datagramsswitch datagrams}

■

■ ATM switches_{ATM switches}

◆

Classification

■

■ Packet vs. circuit switches_{Packet vs. circuit switches}

◆

◆ _{packets have headers and samples don’tpackets have headers and samples don’t}

■

■ Connectionless vs. connection oriented_{Connectionless vs. connection oriented}

◆

◆ _{connection oriented switches need a call setupconnection oriented switches need a call setup}

◆

◆ _{setup is handled insetup is handled in control plane by switch controllercontrol plane}

◆ _{connectionless switches deal with self-contained datagrams}

Connectionless (router) Connection-oriented (switching system) Packet switch

Internet router ATM switching system Circuit

switch

Telephone switching system

Other switching element functions

■

■ Participate in routing algorithms_{Participate in routing algorithms}

◆

◆ _{to build routing tablesto build routing tables}

■

■ Resolve contention for output trunks_{Resolve contention for output trunks}

◆

◆ _{schedulingscheduling}

■

■ Admission control_{Admission control}

◆

◆ _{to guarantee resources to certain streamsto guarantee resources to certain streams}

■

■ We’ll discuss these later_{We’ll discuss these later}

■

Requirements

■

■ Capacity of switch is the maximum rate at which it can move_{Capacity of switch is the maximum rate at which it can move} information, assuming all data paths are simultaneously active

information, assuming all data paths are simultaneously active

■

■ Primary goal:Primary goal: maximize capacitymaximize capacity

◆

◆ _{subject to cost and reliability constraintssubject to cost and reliability constraints}

■

■ Circuit switch must reject call if can’t find a path for samples_{Circuit switch must reject call if can’t find a path for samples} from input to output

from input to output ◆

◆ goal:_goal: minimize call blocking_{minimize call blocking}

■

■ Packet switch must reject a packet if it can’t find a buffer to store_{Packet switch must reject a packet if it can’t find a buffer to store} it awaiting access to output trunk

it awaiting access to output trunk ◆

◆ _{goal:goal: minimize packet lossminimize packet loss}

■

Outline

■

■ Circuit switching_{Circuit switching}

■

■ Packet switchingPacket switching

◆

◆ _{Switch generationsSwitch generations}

◆

◆ _{Switch fabricsSwitch fabrics}

◆

◆ _{Buffer placementBuffer placement}

◆

Circuit switching

■

■ Moving 8-bit samples from an input port to an output port_{Moving 8-bit samples from an input port to an output port}

■

■ Recall that samples have no headersRecall that samples have no headers

■

■ Destination of sample depends on_{Destination of sample depends on} timetime at which it arrives at the_{at which it arrives at the} switch

switch ◆

◆ actually, relative order within a_{actually, relative order within a} frame_frame

■

Multiplexors and demultiplexors

■

■ Most trunks time division multiplex voice samples_{Most trunks time division multiplex voice samples}

■

■ At a central office, trunk is demultiplexed and distributed toAt a central office, trunk is demultiplexed and distributed to active circuits

active circuits

■

■ Synchronous multiplexor_{Synchronous multiplexor}

◆

◆ N input lines_{N input lines}

◆

More on multiplexing

■

■ Demultiplexor_{Demultiplexor}

◆

◆ _{one input line and N outputs that run N times slowerone input line and N outputs that run N times slower}

◆

◆ _{samples are placed in output buffer in round robin ordersamples are placed in output buffer in round robin order}

■

■ Neither multiplexor nor demultiplexor needs addressing_{Neither multiplexor nor demultiplexor needs addressing} information (why?)

information (why?)

■

■ Can cascade multiplexors_{Can cascade multiplexors}

◆

◆ _{need a standardneed a standard}

◆

Inverse multiplexing

■

■ Takes a high bit-rate stream and scatters it across multiple_{Takes a high bit-rate stream and scatters it across multiple} trunks

trunks

■

■ At the other end, combines multiple streamsAt the other end, combines multiple streams

◆

◆ _{resequencingresequencing to accommodate variation in delaysto accommodate variation in delays}

■

A circuit switch

■

■ A switch that can handle N calls has N logical inputs and N_{A switch that can handle N calls has N logical inputs and N} logical outputs

logical outputs ◆

◆ _{N up to 200,000N up to 200,000}

■

■ In practice, input trunks are multiplexed_{In practice, input trunks are multiplexed}

◆

◆ _{example: DS3 trunk carries 672 simultaneous callsexample: DS3 trunk carries 672 simultaneous calls}

■

■ Multiplexed trunks carry_{Multiplexed trunks carry} framesframes = set of samples_{= set of samples}

■

■ Goal: extract samples from frame, and depending on position in_{Goal: extract samples from frame, and depending on position in} frame, switch to output

frame, switch to output ◆

◆ _{each incoming sample has to get to the right output line and theeach incoming sample has to get to the right output line and the}

right slot in the output frame

right slot in the output frame

◆

Call blocking

■

■ Can’t find a path from input to output_{Can’t find a path from input to output}

■

■ Internal blockingInternal blocking

◆

◆ _{slot in output frame exists, but no pathslot in output frame exists, but no path}

■

■ Output blocking_{Output blocking}

◆

◆ no slot in output frame is available_{no slot in output frame is available}

■

■ Output blocking is reduced in_{Output blocking is reduced in} transit_transit switches_switches

◆

◆ _{need to put a sample in one ofneed to put a sample in one of} several slots going to the desired_several

Time division switching

■

■ Key idea: when_{Key idea: when} demultiplexing_{demultiplexing}, position in frame determines_{, position in frame determines} output trunk

output trunk

■

■ Time division switching interchanges sample position within aTime division switching interchanges sample position within a frame: time slot interchange (TSI)

How large a TSI can we build?

■

■ Limit is time taken to read and write to memory_{Limit is time taken to read and write to memory}

■

■ For 120,000 circuitsFor 120,000 circuits

◆

◆ _{need to read and write memory once every 125 microsecondsneed to read and write memory once every 125 microseconds}

◆

◆ _{each operation takes around 0.5each operation takes around 0.5 nsns => impossible with current=> impossible with current}

technology

technology

■

Space division switching

■

■ Each sample takes a different path_{Each sample takes a different path} thoguh_thoguh the_the swithc_swithc,_, depending on its destination

Crossbar

■

■ Simplest possible space-division switch_{Simplest possible space-division switch}

■

■ Crosspoints can be turned on or offCrosspoints

■ For multiplexed inputs, need a switching schedule (why?) ■ Internally nonblocking

◆ _{but need N}2 _crosspoints

◆ _{time taken to set each crosspoint grows quadratically} ◆ _{vulnerable to single faults (why?)}

Multistage crossbar

■

■ In a crossbar during each switching time only one_{In a crossbar during each switching time only one} crosspoint_crosspoint per_per row or column is active

row or column is active

■

■ Can save crosspoints if aCan save crosspoints if a crosspointcrosspoint can attach to more thancan attach to more than one input line (why?)

one input line (why?)

■

■ This is done in a multistage crossbar_{This is done in a multistage crossbar}

■

Multistage crossbar

■

■ Can suffer internal blocking_{Can suffer internal blocking}

◆

◆ _{unless sufficient number of second-level stagesunless sufficient number of second-level stages}

■

■ Number of crosspoints < N_{Number of crosspoints < N}22

■

■ Finding a path from input to output requires a depth-first-search_{Finding a path from input to output requires a depth-first-search}

■

■ Scales better than crossbar, but still not too well_{Scales better than crossbar, but still not too well}

◆

Time-space switching

■

■ Precede each input trunk in a crossbar with a TSI_{Precede each input trunk in a crossbar with a TSI}

■

■ Delay samples so that they arrive at the right time for the spaceDelay samples so that they arrive at the right time for the space division switch’s schedule

Time-space-time (TST) switching

■

■ Allowed to flip samples both on input and output trunk_{Allowed to flip samples both on input and output trunk}

■

Outline

■

■ Circuit switching_{Circuit switching}

■

■ Packet switchingPacket switching

◆

◆ _{Switch generationsSwitch generations}

◆

◆ _{Switch fabricsSwitch fabrics}

◆

◆ _{Buffer placementBuffer placement}

◆

Packet switching

■

■ In a circuit switch, path of a sample is determined at time of_{In a circuit switch, path of a sample is determined at time of} connection establishment

connection establishment

■

■ No need for a sample header--position in frame is enoughNo need for a sample header--position in frame is enough

■

■ In a packet switch, packets carry a destination field_{In a packet switch, packets carry a destination field}

■

■ Need to look up destination port on-the-fly_{Need to look up destination port on-the-fly}

■

■ Datagram_Datagram

◆

◆ _{lookup based on entire destination addresslookup based on entire destination address}

■

■ Cell_Cell

◆

◆ _{lookup based on VCIlookup based on VCI}

■

Repeaters, bridges, routers, and gateways

■

■ Repeaters: at physical level_{Repeaters: at physical level}

■

■ Bridges: at datalink level (based on MAC addresses) (L2)Bridges: at datalink level (based on MAC addresses) (L2)

◆

◆ _{discover attached stations by listeningdiscover attached stations by listening}

■

■ Routers: at network level (L3)_{Routers: at network level (L3)}

◆

◆ participate in routing protocols_{participate in routing protocols}

■

■ Application level gateways: at application level (L7)_{Application level gateways: at application level (L7)}

◆

◆ _{treat entire network as a single hoptreat entire network as a single hop}

◆

◆ _{e.g mail gateways ande.g mail gateways and transcoderstranscoders}

■

■ Gain functionality at the expense of forwarding speed_{Gain functionality at the expense of forwarding speed}

◆

Port mappers

■

■ Look up output port based on destination address_{Look up output port based on destination address}

■

■ Easy for VCI: just use a tableEasy for VCI: just use a table

■

■ Harder for datagrams:_{Harder for datagrams:}

◆

◆ need to find_{need to find} longest prefix match_{longest prefix match}

✦

✦ e.g. packet with address 128.32.1.20e.g. packet with address 128.32.1.20

✦

✦ entries: (128.32.*, 3), (128.32.1.*, 4), (128.32.1.20, 2)entries: (128.32.*, 3), (128.32.1.*, 4), (128.32.1.20, 2)

■

Tries

■

■ Two ways to improve performance_{Two ways to improve performance}

◆

◆ cache recently used addresses in a CAM_{cache recently used addresses in a CAM}

◆

Blocking in packet switches

■

■ Can have both internal and output blocking_{Can have both internal and output blocking}

■

■ InternalInternal

◆

◆ _{no path to outputno path to output}

■

■ Output_Output

◆

◆ trunk unavailable_{trunk unavailable}

■

■ Unlike a circuit switch, cannot predict if packets will block (why?)_{Unlike a circuit switch, cannot predict if packets will block (why?)}

■

Dealing with blocking

■

■ Overprovisioning_{Overprovisioning}

◆

◆ _{internal links much faster than inputsinternal links much faster than inputs}

■

■ Buffers_Buffers

◆

◆ _{at input or outputat input or output}

■

■ Backpressure_Backpressure

◆

◆ _{if switch fabric doesn’t have buffers, prevent packet from enteringif switch fabric doesn’t have buffers, prevent packet from entering}

until path is available

until path is available

■

■ Parallel switch fabrics_{Parallel switch fabrics}

◆

Outline

■

■ Circuit switching_{Circuit switching}

■

■ Packet switchingPacket switching

◆

◆ _{Switch generationsSwitch generations}

◆

◆ _{Switch fabricsSwitch fabrics}

◆

◆ _{Buffer placementBuffer placement}

◆

Three generations of packet switches

■

■ Different trade-_{Different trade-}offs_offs between cost and performance_{between cost and performance}

■

■ Represent evolution in switching capacity, rather than inRepresent evolution in switching capacity, rather than in technology

technology ◆

◆ _{With same technology, a later generation switch achieves greaterWith same technology, a later generation switch achieves greater}

capacity, but at greater cost

capacity, but at greater cost

■

First generation switch

■

■ Most Ethernet switches and cheap packet routers_{Most Ethernet switches and cheap packet routers}

■

Example

■

■ First generation router built with 133 MHz Pentium_{First generation router built with 133 MHz Pentium}

◆

◆ _{Mean packet size 500 bytesMean packet size 500 bytes}

◆

◆ _{Interrupt takes 10 microseconds, word access take 50Interrupt takes 10 microseconds, word access take 50 nsns}

◆

◆ _{Per-packet processing time takes 200 instructions = 1.504 µsPer-packet processing time takes 200 instructions = 1.504 µs}

■

■ Copy loopCopy loop

register <- memory[read_

register <- memory[read_ptrptr]] memory [write_

memory [write_ptrptr] <- register] <- register read_

read_ptrptr <- read_<- read_ptrptr + 4+ 4 write_

write_ptrptr <- write_<- write_ptrptr + 4+ 4

counter <- counter -1

counter <- counter -1

if (counter not 0) branch to top of loop

if (counter not 0) branch to top of loop

■

■ 4 instructions + 2 memory accesses = 130.08_{4 instructions + 2 memory accesses = 130.08} ns_ns

■

■ Copying packet takes 500/4 *130.08 = 16.26 µs; interrupt 10 µs_{Copying packet takes 500/4 *130.08 = 16.26 µs; interrupt 10 µs}

■

■ Total time = 27.764 µs => speed is 144.1Total time = 27.764 µs => speed is 144.1 MbpsMbps

■

Second generation switch

■

■ Port mapping intelligence in line cards_{Port mapping intelligence in line cards}

■

■ ATM switch guarantees hit in lookup cache_{ATM switch guarantees hit in lookup cache}

■

■ Ipsilon_Ipsilon IP switchingIP switching

◆

◆ _{assume underlying ATM networkassume underlying ATM network}

◆

◆ _{by default, assemble packetsby default, assemble packets}

◆

◆ _{if detect a flow, ask upstream to send on a particular VCI, andif detect a flow, ask upstream to send on a particular VCI, and}

install entry in port

Third generation switches

■

■ Bottleneck in second generation switch is the bus (or ring)_{Bottleneck in second generation switch is the bus (or ring)}

■

Third generation (contd.)

■

■ Features_Features

◆

◆ _{self-routing fabricself-routing fabric}

◆

◆ _{output buffer is a point of contentionoutput buffer is a point of contention}

✦

✦ unless weunless we arbitratearbitrate access to fabricaccess to fabric

◆

◆ _{potential for unlimited scaling, as long as we can resolve contentionpotential for unlimited scaling, as long as we can resolve contention}

for output buffer

Outline

■

■ Circuit switching_{Circuit switching}

■

■ Packet switchingPacket switching

◆

◆ _{Switch generationsSwitch generations}

◆

◆ _{Switch fabricsSwitch fabrics}

◆

◆ _{Buffer placementBuffer placement}

◆

Switch fabrics

■

■ Transfer data from input to output, ignoring scheduling and_{Transfer data from input to output, ignoring scheduling and} buffering

buffering

■

Crossbar

■

■ Simplest switch fabric_{Simplest switch fabric}

◆

◆ _{think of it as 2N buses in parallelthink of it as 2N buses in parallel}

■

■ Used here for_{Used here for} packetpacket routing:_routing: crosspoint_crosspoint is left open long_{is left open long} enough to transfer a packet from an input to an output

enough to transfer a packet from an input to an output

■

■ For fixed-size packets and known arrival pattern, can compute_{For fixed-size packets and known arrival pattern, can compute} schedule in advance

schedule in advance

■

■ Otherwise, need to compute a schedule on-the-fly (what does_{Otherwise, need to compute a schedule on-the-fly (what does} the schedule depend on?)

Buffered crossbar

■

■ What happens if packets at two inputs both want to go to same_{What happens if packets at two inputs both want to go to same} output?

output?

■

■ Can defer one at an input bufferCan defer one at an input buffer

■

Broadcast

■

■ Packets are tagged with output port #_{Packets are tagged with output port #}

■

■ Each output matches tags_{Each output matches tags}

■

■ Need to match N addresses in parallel at each output_{Need to match N addresses in parallel at each output}

■

Switch fabric element

■

■ Can build complicated fabrics from a simple element_{Can build complicated fabrics from a simple element}

■

■ Routing rule: if 0, send packet to upper output, else to lower_{Routing rule: if 0, send packet to upper output, else to lower} output

output

■

Features of fabrics built with switching elements

■

■ NxN_NxN switch with_{switch with} bxb_bxb elements has_{elements has} elements with_{elements with} elements per stage

elements per stage

■

■ Fabric isFabric is self routingself routing

■

■ Recursive_Recursive

■

■ Can be synchronous or asynchronous_{Can be synchronous or asynchronous}

■

■ Regular and suitable for VLSI implementation_{Regular and suitable for VLSI implementation}

log

N

Banyan

■

■ Simplest self-routing recursive fabric_{Simplest self-routing recursive fabric}

■

■ (why does it work?)_{(why does it work?)}

■

■ What if two packets both want to go to the same output?_{What if two packets both want to go to the same output?}

◆

Blocking

■

■ Can avoid with a buffered_{Can avoid with a buffered} banyan_banyan switch_switch

◆

◆ _{but this is too expensivebut this is too expensive}

◆

◆ _{hard to achieve zero loss even with buffershard to achieve zero loss even with buffers}

■

■ Instead, can check if path is available before sending packet_{Instead, can check if path is available before sending packet}

◆

◆ _{three-phase schemethree-phase scheme}

◆

◆ _{send requestssend requests}

◆

◆ _{inform winnersinform winners}

◆

◆ _{send packetssend packets}

■

■ Or, use several_{Or, use several} banyan_banyan fabrics in parallel_{fabrics in parallel}

◆

◆ intentionally misroute and tag one of a colliding pair_{intentionally misroute and tag one of a colliding pair}

◆

◆ divert tagged packets to a second_{divert tagged packets to a second} banyan_banyan, and so on to k stages_{, and so on to k stages}

◆

◆ _{expensiveexpensive}

◆

◆ can reorder packets_{can reorder packets}

◆

Sorting

■

■ Can avoid blocking by choosing order in which packets appear_{Can avoid blocking by choosing order in which packets appear} at input ports

at input ports

■

■ If we canIf we can

◆

◆ _{present packets at inputs sorted by outputpresent packets at inputs sorted by output}

◆

◆ _{remove duplicatesremove duplicates}

◆

◆ _{remove gapsremove gaps}

◆

◆ _{precedeprecede banyanbanyan with a perfect shuffle stagewith a perfect shuffle stage}

◆

◆ _{then no internal blockingthen no internal blocking}

■

■ For example, [X, 010, 010, X, 011, X, X, X] -(sort)->_{For example, [X, 010, 010, X, 011, X, X, X] -(sort)->} [010, 011, 011, X, X, X, X, X] -(remove

[010, 011, 011, X, X, X, X, X] -(remove dupsdups)->)-> [010, 011, X, X, X, X, X, X] -(shuffle)->

[010, 011, X, X, X, X, X, X] -(shuffle)->

[010, X, 011, X, X, X, X, X]

[010, X, 011, X, X, X, X, X]

■

Sorting

■

■ Build sorters from merge networks_{Build sorters from merge networks}

■

■ Assume we can merge two sorted listsAssume we can merge two sorted lists

■

Putting it together- Batcher Banyan

■

■ What about trapped duplicates?_{What about trapped duplicates?}

◆

◆ recirculate_recirculate to beginning_{to beginning}

◆

Effect of packet size on switching fabrics

■

■ A major motivation for small fixed packet size in ATM is ease of_{A major motivation for small fixed packet size in ATM is ease of} building large parallel fabrics

building large parallel fabrics

■

■ In general, smaller size => more per-packet overhead, but moreIn general, smaller size => more per-packet overhead, but more preemption points/sec

preemption points/sec ◆

◆ _{At high speeds, overhead dominates!At high speeds, overhead dominates!}

■

■ Fixed size packets helps build synchronous switch_{Fixed size packets helps build synchronous switch}

◆

◆ But we could fragment at entry and reassemble at exit_{But we could fragment at entry and reassemble at exit}

◆

◆ _{Or build an asynchronous fabricOr build an asynchronous fabric}

◆

◆ Thus, variable size doesn’t hurt too much_{Thus, variable size doesn’t hurt too much}

■

■ Maybe Internet routers can be almost as cost-effective as ATM_{Maybe Internet routers can be almost as cost-effective as ATM} switches

Outline

■

■ Circuit switching_{Circuit switching}

■

■ Packet switchingPacket switching

◆

◆ _{Switch generationsSwitch generations}

◆

◆ _{Switch fabricsSwitch fabrics}

◆

◆ _{Buffer placementBuffer placement}

◆

Buffering

■

■ All packet switches need buffers to match input rate to service_{All packet switches need buffers to match input rate to service} rate

rate ◆

◆ _{or cause heavy packet losesor cause heavy packet loses}

■

■ Where should we place buffers?_{Where should we place buffers?}

◆

◆ _inputinput

◆

◆ _{in the fabricin the fabric}

◆

◆ _outputoutput

◆

Input buffering (input queueing)

■

■ No speedup in buffers or trunks (unlike output queued switch)_{No speedup in buffers or trunks (unlike output queued switch)}

■

■ Needs arbiter_{Needs arbiter}

■

■ Problem:_Problem: head of line blocking_{head of line blocking}

◆

◆ _{with randomly distributed packets, utilization at most 58.6%with randomly distributed packets, utilization at most 58.6%}

◆

Dealing with HOL blocking

■

■ Per-output queues at inputs_{Per-output queues at inputs}

■

■ Arbiter must choose one of the input ports for each output portArbiter must choose one of the input ports for each output port

■

■ How to select?_{How to select?}

■

■ Parallel Iterated Matching_{Parallel Iterated Matching}

◆

◆ _{inputs tell arbiter which outputs they are interested ininputs tell arbiter which outputs they are interested in}

◆

◆ _{output selects one of the inputsoutput selects one of the inputs}

◆

◆ _{some inputs may get more than onesome inputs may get more than one} grant_{grant, others may get none, others may get none}

◆

◆ _{if >1 grant, input picks one at random, and tells outputif >1 grant, input picks one at random, and tells output}

◆

◆ _{losing inputs and outputs try againlosing inputs and outputs try again}

■

Output queueing

■

■ Don’t suffer from head-of-line blocking_{Don’t suffer from head-of-line blocking}

■

■ But output buffers need to run much faster than trunk speed_{But output buffers need to run much faster than trunk speed} (why?)

(why?)

■

■ Can reduce some of the cost by using the_{Can reduce some of the cost by using the} knockoutknockout principle_principle

◆

◆ _{unlikely that all N inputs will have packets for the same outputunlikely that all N inputs will have packets for the same output}

◆

Shared memory

■

■ Route only the header to output port_{Route only the header to output port}

■

■ Bottleneck is time taken to read and write_{Bottleneck is time taken to read and write} multiported_multiported memory_memory

■

■ Doesn’t scale to large switches_{Doesn’t scale to large switches}

■

Datapath: clever shared memory design

■

■ Reduces read/write cost by doing wide reads and writes_{Reduces read/write cost by doing wide reads and writes}

■

Buffered fabric

■

■ Buffers in each switch element_{Buffers in each switch element}

■

■ ProsPros

◆

◆ _{Speed up is only as much as fan-inSpeed up is only as much as fan-in}

◆

◆ _{HardwareHardware backpressurebackpressure reduces buffer requirementsreduces buffer requirements}

■

■ Cons_Cons

◆

◆ _{costly (unless using single-chip switches)costly (unless using single-chip switches)}

◆

Hybrid solutions

■

■ Buffers at more than one point_{Buffers at more than one point}

■

■ Becomes hard to analyze and manageBecomes hard to analyze and manage

■

Outline

■

■ Circuit switching_{Circuit switching}

■

■ Packet switchingPacket switching

◆

◆ _{Switch generationsSwitch generations}

◆

◆ _{Switch fabricsSwitch fabrics}

◆

◆ _{Buffer placementBuffer placement}

◆

Multicasting

■

■ Useful to do this in hardware_{Useful to do this in hardware}

■

■ AssumeAssume portmapperportmapper knows list of outputsknows list of outputs

■

■ Incoming packet must be copied to these output ports_{Incoming packet must be copied to these output ports}

■

■ Two_Two subproblems_subproblems

◆

◆ _{generating and distributing copesgenerating and distributing copes}

◆

Generating and distributing copies

■

■ Either implicit or explicit_{Either implicit or explicit}

■

■ ImplicitImplicit

◆

◆ _{suitable for bus-based, ring-based, crossbar, or broadcast switchessuitable for bus-based, ring-based, crossbar, or broadcast switches}

◆

◆ _{multiple outputs enabled after placing packet on shared busmultiple outputs enabled after placing packet on shared bus}

◆

◆ _{used in Paris andused in Paris and DatapathDatapath switchesswitches}

■

■ Explicit_Explicit

◆

◆ need to copy a packet at switch elements_{need to copy a packet at switch elements}

◆

◆ use a_{use a} copy_copy network_network

◆

◆ _{place # of copies in tagplace # of copies in tag}

◆

◆ element copies to both outputs and decrements count on one of_{element copies to both outputs and decrements count on one of}

them

them

◆

◆ _{collect copies at outputscollect copies at outputs}

■

Header translation

■

■ Normally, in-VCI to out-VCI translation can be done either at_{Normally, in-VCI to out-VCI translation can be done either at} input or output

input or output

■

■ With multicasting, translation easier at output port (why?)With multicasting, translation easier at output port (why?)

■

■ Use separate port mapping and translation tables_{Use separate port mapping and translation tables}

■

■ Input maps a VCI to a set of output ports_{Input maps a VCI to a set of output ports}

■

■ Output port swaps VCI_{Output port swaps VCI}

■