text
stringlengths 2
132k
| source
dict |
|---|---|
enforcement, 810-8 Environmental documents geotechnical report, 510-5 Environmental hearing, 210-11 Environmental Review Summary (ERS), 330-7 Erosion prevention, 1350-2 ERS. See Environmental Review Summary Escape ramps, 1010-4 Evaluate upgrade (EU), 325-7 Exit pattern uniformity, 940-4 F Farmlands, 210-7 Farm road approach, 920-3 Federal aid R/W documents, 1410-6 Federal lands R/W transactions, 1410-5 Fencing, 1460-1 chain link, 1460-2 design criteria, 1460-1 documentation, 1460-3 fencing types, 1460-2 gates, 1460-3 limited access highways, 1460-1 managed access highways, 1460-2 procedure, 1460-3 special sites, 1460-2 wire fencing, 1460-3 Ferry System Plan, 120-11 Fill slope, 640-4 Findings and order, 210-14 plan, 220-5, 1430-2 Flood plains, 210-7, 1210-1 Flyer stop, 1050-2, 1050-3, 1050-5, 1055-3, 1055-8 Freeway lighting applications, 840-9 Freight Rail Plan, 120-9 Frontage roads, 620-3, 1430-10 Full design level, 440-1 city streets and county roads, 440-4 curbs, 440-8 design speed, 440-1, 440-4 functional classification, 440-3 geometric design data, 440-4 grades, 440-10 medians, 440-7 parking, 440-9 pavement type, 440-9 right of way width, 440-9 shoulders, 440-5 state highways as city streets, 440-4 state highway system, 440-4 structure width, 440-9 terrain classification, 440-3 traffic lanes, 440-5 Index Design Manual M 22-01 Page 6 May 2006 Functional classification, 120-7, 440-3 Funding. See Programming G G-R-E-A-T impact attenuator, 720-6, 720-16 Gabion walls, 1130-10 Gap acceptance length, HOV direct access, 1055-7 Gates, 1460-3 Geometric cross section, 640-1 medians, 640-3 Outer separations, 640-3 roadsides, 640-4 roadways, 640-2 shoulders, 640-2 superelevation, 642-1 traveled way cross slope, 640-2 turning roadway widths, 640-2 Geometric design data, 440-4 Geometric plan elements, 620-1 arrangement of lanes, 620-4 distribution facilities, 620-3 frontage roads, 620-3 horizontal alignment, 620-1 horizontal curve radii, 620-2 lane transitions, 620-4 median width transitions, 620-5 number of lanes and arrangement, 620-4 pavement transitions, 620-4 Geometric profile elements, 630-1 airport clearance, 630-4 alignment on structures, 630-2 coordination of vertical and horizontal alignments, 630-2 design controls, 630-1 grade
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
length, 630-2 length of grade, 630-2 maximum grades, 630-2 minimum grades, 630-2 minimum length of vertical curves, 630-2 railroad crossings, 630-4 vertical alignment, 630-1 Geometrics horizontal alignment, 620-1 HOV direct access, 1055-5 vertical alignment, 630-1 Geosynthetics, 530-1 applications, 530-2, 530-16 definition, 530-2 design approach, 530-3 design process, 530-12 design responsibility, 530-11 ditch lining, 530-6 documentation, 530-11 erosion control, 530-5 function, 530-2 separation, 530-4 site-specific designs, 530-9 soil stabilization, 530-5 standard specification, 530-9 temporary silt, 530-20 temporary silt fence, 530-6 types, 530-14 types and characteristics, 530-1 underground drainage, 530-3 Geosynthetic soil reinforcement, 1130-9 Geotechnical investigation, design, and reporting, 510-2 bridge foundations, 510-11 buildings, 510-7 cantilever signs, 510-6 communication towers, 510-7 consultants, 510-14 documentation, 510-14 earthwork, 510-4 ferries projects, 510-13 hydraulic structures, 510-5 key contacts, 510-2 luminaire, 510-6 noise walls, 510-8 park and ride lots, 510-7 permits, 510-3 reinforced slopes, 510-8 rest areas, 510-7 retaining walls, 510-8 rockslope, 510-10 signals, 510-6 sign bridges, 510-6 site data, 510-3 surfacing report, 510-14 unstable slopes, 510-9 Design Manual M 22-01 Index May 2006 Page Geotextiles descriptions, 530-1 standard specification, 530-9 types, 530-15 Gore, 940-1, 940-8 HOV drop ramp, 1055-21 Grade intersections, 910-1 Grades, 440-10, 915-12, 1055-6 bikeway, 1020-6 maximum, 440-10, 630-2 minimum, 630-2 ramp, 940-5 roundabouts, 915-12 shared use path, 1020-14 vertical alignment, 630-2 Grading, contour, 1310-1 Gravity walls, 1130-1 Growth Management Act, 120-2, 120-5, 120-11, 120-12 Guardrail placement cases, 710-12, 710-18 steel backed timber guardrail, 710-18 terminals and anchors, 710-9 thrie beam, 710-7, 710-13 W-beam, 710-7, 710-13 Guidelines for wall/slope selection, 1130-5 cost considerations, 1130-8 cut and fill considerations, 1130-5 facing options, 1130-7 feasible wall and slope heights and applications, 1130-7 settlement and deep foundation support considerations, 1130-6 summary, 1130-8 supporting structures or utilities, 1130-7 Guide posts, 830-7 Guide sign plan, 820-4 H HAR, definition, 860-4 Hazard, 700-3 definition, 700-2 Hearings, 210-6 access,
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
210-12, 1430-2, 1430-12 administrative appeal, 210-15 advertising, 210-7 combined, 210-15 corridor, 210-11 design, 210-12 environmental, 210-11 examiner, 210-13 findings and order, 210-14 formal, 210-4 informal, 210-4 notice, 210-7 open format, 210-4 preparation, 210-8 requirements, 210-6 sequence, 210-16 study plan, 210-3, 210-11 Heritage tour route barrier, 710-4 Hex-Foam Sandwich impact attenuator, 720-7, 720-17 High occupancy vehicle (HOV) facilities, 1050-1. See also HOV direct access arterial street, 1050-5, 1050-9 buffer-separated, 1050-3, 1050-9 design criteria, 1050-7 direct access, 1055-1 direct access ramp, 1050-2, 1050-3, 1050-5, 1050-9 enforcement, 1050-7 enforcement areas, 1050-9, 1050-10, 1050-13 through 1050-15 facility type, 1050-3 freeway, 1050-3 ITS, 1050-7 lane termination, 1050-9 nonseparated, 1050-3, 1050-9 preliminary design and planning, 1050-2 ramp meter bypass design criteria, 1050-9, 1050-13, 1050-14 separated roadway, 1050-3, 1050-8, 1050-11 signs and pavement markings, 1050-10 vehicle occupancy designation, 1050-6 Index Design Manual M 22-01 Page May 2006 Highway as city streets, 440-4 state system, 440-4 Highway-highway separation, 1110-3 Highway-railroad separation, 1110-3 Highway advisory radio (HAR), 860-4 Highway construction program, 150-4 Highways and Local Programs Division, 120-10 Highways of Statewide Significance, 120-6 Horizontal alignment, 620-1 Horizontal clearance, bridge, 1120-2 Horizontal curve radii, 620-2 HOV direct access, 1055-1 acceleration lanes, 1055-6 deceleration lanes, 1055-7 design speeds, 1055-5 design vehicles, 1055-5 direct access geometrics, 1055-5 flyer stops, 1055-8 gap acceptance length, 1055-7 grades, 1055-6 intelligent transportation systems, 1055-10 lighting, 1055-10 locations, 1055-3 Off-connections, 1055-7 on-connections, 1055-6 passenger access, 1055-8 ramp spacing, 1055-3 ramp widths, 1055-6 sight distance, 1055-5 signing, 1055-9 traffic barriers, 1055-9 traffic design elements, 1055-9 transit stops, 1055-4 types, 1055-3 vertical clearance, 1055-7 HOV facilities. See High occupancy vehicle facilities; See high occupancy vehicle (HOV) facilities Hydraulic considerations, 1210-1 channel changes, 1210-2 flood plain, 1210-1 roadway drainage, 1210-2 runoff, 1210-3 stream crossings, 1210-2 subsurface discharge, 1210-3 subsurface drainage, 1210-3 Hydraulic design, 1210-1 design responsibility, 1210-3 geotechnical investigation,
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
510-5 hydraulic considerations, 1210-1 safety considerations, 1210-3 I Illumination, 915-14 bridges, 840-5 construction zones and detours, 840-4 roundabouts, 915-14 Impact attenuator systems, 720-1 design criteria, 720-7 object markers, 830-8 older systems, 720-6 permanent installations, 720-1 selection, 720-7 work zone installation, 720-4 Inertial barrier, 720-3, 720-5, 720-14 Inscribed diameter, 915-9 Intelligent Transportation Systems (ITS), 1055-10 HOV facilities, 1050-7 Intelligent transportation systems (ITS), 860-1 closed circuit television cameras, 860-1 dynamic message signs, 860-4 highway advisory radio, 860-4 HOV bypass, 860-4 motorist information, 860-4 National ITS Architecture, 860-1 public information components, 860-4 surveillance, control, and driver information, 860-1 traffic data collection, 860-2 traffic flow control, 860-3 traffic operations center (TOC), 860-2 Traffic Systems Management Center (TSMC), 860-2 Venture Washington, 860-1 Interchanges. See Traffic interchanges access control, 1430-3 HOV direct access, 1055-1 HOV off-connections, 1055-7 HOV on-connections, 1055-6 Design Manual M 22-01 Index May 2006 Page International boundaries, R/W, 1410-2 Intersections at grade, 910-1 angle, 910-3 channelization, 910-6 configurations, 910-3 crossroads, 910-4 design considerations, 910-3 design vehicle, 910-4 island, 910-9 left-turn lanes, 910-6 median crossover, 910-2 right-turn corners, 910-5 roundabouts, 915-1 spacing, 910-4 transit, 1060-11, 1060-12 Interstate, 325-1, 440-11 Intesection at grade superelevation, 642-3 Irrigation, 1330-1 Islands, 910-9 roundabouts, 915-12 ITS, 1055-10 ITS, definition, 860-1 J Jurisdiction Over State Highways, DM Supplement 1/22/2003, 1050-14 K K-factor, 610-2 L Landscaping, 1330-1, 1350-1 Lane, 440-5, 940-6 acceleration, 1055-6 balance, 940-6 bike, 1020-1, 1020-4 climbing, 1010-2 deceleration, 1055-7 drop, 910-8 left-turn, 910-6 number and arrangement, 620-4 passing, 1010-3 reduction, 940-6 right-turn, 910-8 speed change, 910-9 transitions, 620-4 width, 440-5, 1055-6 width, turning roadway, 641-1 Lane lines. See Pavement markings Lead Agency, 610-2 Left-turn lanes, 910-6 one-way, 910-6 storage, 910-7 two-way, 910-8 Length of need, traffic barrier, 710-6 definition, 710-1 Level of Service (LOS) climbing lane warrant, 1010-2 Lighting, 1055-10 Light standards, 840-7 geotechnical investigation, 510-6 Limited
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
access, 1430-1 approach, 1420-2 definitions, 1420-2, 1420-4 full control, 1430-3 level of control, 1430-1 limits, 1430-15, 1430-16, 1430-17, 1430-18, 1430-19, 1430-20, 1430-21, 1430-22 modifications to, 1430-12 modified control, 1430-8 partial control, 1430-5 references, 1420-1 vocabulary, 1420-5 Limits turnback, 1430-11 LMA impact attenuator, 720-7, 720-17 Load rating, bridges, 1120-1 Local agency bridge design, 1120-2 Longitudinal barrier. See Traffic barrier Loop ramp connections, 940-9 Low clearance warning signs, 1120-3 Luminaire. See Light standards Index Design Manual M 22-01 Page 10 May 2006 M Mailboxes limited access, 1430-5, 1430-7, 1430-10 Managed access access connection, 1435-1 Class, 1435-1 connections, 1420-2, 1420-3 corner clearance, 1435-6 definitions, 1420-2 permit, 1435-8 references, 1420-1 vocabulary, 1420-5 Manual on Uniform Traffic Control Devices (MUTCD), 820-1, 830-1, 850-1, 860-2, 1120-3 Maps. See Plans Masonry concrete blocks, 1130-7 Mast arm signal standards, 850-13 Master Plan for Limited Access Highways, 120-7, 1420-4 Materials sources, 510-1, 510-15 Matrix. See Design matrix Mechanically Stabilized Earth (MSE), 1130-1, 1130-22 Median, 440-7 design, 640-3 safety considerations, 700-7 transitions, 620-5 width, 440-8 Memorandum of Understanding WSP, 1040-2 Metal bin walls, 1130-11 Metropolitan Planning, 120-2, 120-3, 120-4, 120-8, 120-10, 120-11 Metropolitan Planning Organizations (MPO), 120-3 Metropolitan Transportation Improvement Program (MTIP), 120-4, 120-12 Mileposts markers, 820-4 sign, 820-4 Military Traffic Management Command Transportation Engineering Agency (MTMCTEA), 1120-3 Minor arterial, 440-14 Minor operational enhancement projects, 340-1 matrix procedures, 340-4 project approval, 340-5 project types, 340-2 selecting a matrix, 340-4 using a matrix, 340-4 Minor safety and minor preservation work, 410-1 Monotube cantilever sign supports, 820-3 Monotube sign bridges, 820-3 Mopeds, 1020-1 Motorist information, 860-4 additional public information components, 860-4 dynamic message signs, 860-4 highway advisory radio, 860-4 Mountable curbs, 440-9 Moveable barriers, 810-10 MTMCTEA, 1120-3 MUTCD, 820-1, 830-1, 850-1, 860-2 N N-E-A-T impact attenuator, 720-5, 720-14 National Highway System (NHS), 325-1 Interstate System, 325-1 Strategic Highway Corridor Network (STRAHNET), 325-1
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
National ITS Architecture, 860-1 New Jersey shape barrier, 710-15 Noise barriers, 1140-1 design, 1140-1 documentation, 1140-4 earth berm, 1140-2 geotechnical investigation, 510-8 noise wall, 1140-2 procedures, 1140-4 wall types, 1140-3 Non-NHS highways, 325-2 Nonrecoverable slope, 700-2 Nonseparated HOV lanes, 1050-2, 1050-3, 1050-5, 1050-7, 1050-9, 1050-11 Notional live load, 1120-1 Design Manual M 22-01 Index May 2006 Page 11 O Object markers, 830-8 Off connections, 940-7 On connections, 940-7 One-way left-turn lanes, 910-6 Open house meetings, 210-4 Outer separations, 640-3 Overhead Sign Illumination (Lighting) DM Supplement (8/5/2005) Overhead sign installations, 820-3 P Park and ride lots, 1060-1 access, 1060-3 bicycle facilities, 1060-5 design, 1060-2 drainage, 1060-5 fencing, 1060-6 geotechnical investigation, 510-7 HOV direct access, 1055-3, 1055-5 illumination, 1060-6 internal circulation, 1060-4 landscape, 1060-6 maintenance, 1060-6 motorcycle facilities, 1060-5 pavement design, 1060-5 pedestrian movement, 1060-4 shelters, 1060-5 site selection, 1060-2 stall size, 1060-4 traffic control, 1060-5 Parking, 440-9 roundabouts, 915-14 Partial cloverleaf, 940-3 Pass-by-trips, 610-2 Passenger access, transit, 1055-8 Passing lanes, 1010-3 Pavement transitions, 620-4 Pavement markings longitudinal, 830-2 roundabouts, 915-13 transverse, 830-3 Pavement structure, 520-1 Pavement Type Selection Protocol (PTSP) DM Supplement (5/16/2005) PCMS, 810-10 PD. See Project Definition Pedestrian bridge, 1120-3 Pedestrian crossings at grade limited access, 1430-5, 1430-7, 1430-10 Pedestrian design considerations bridges, 1120-4 roundabouts, 915-13 Permits construction, 1410-3 geotechnical permits, 510-3 managed access, 1435-8 right of way, 1410-2 traffic signal, 850-2 Permits and approvals, 240-1 Physical barriers, 810-9 Pit sites, R/W, 1410-2 Planning planning and programming, 120-14 Plans access, findings and order, 1430-2 access, intersection, 1430-13, 1430-14 access hearing, 210-13, 1410-6, 1430-2, 1430-3 access report, 1430-2, 1430-3 environmental study, 210-3, 220-2 findings and order, 220-5 guide sign, 820-4 interchange, 940-10 limited access, 1410-2 limited access, modifications to, 1430-12 PS&E, R/W, 1410-4 public involvement, 210-3 right of way, 1410-1, 1410-3, 1410-4 right of way and limited access, 1430-1, 1430-2,
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
1430-5, 1430-8, 1430-10, 1430-12, 1430-13 Portable changeable message signs, 810-10 Portable traffic signals, 810-12 Preliminary signal plan, 850-14 Principal arterial, 440-12 Private land R/W transactions, 1410-4 Profile grades, 440-10 Program elements, 150-6 Index Design Manual M 22-01 Page 12 May 2006 Programming R/W appraisal and acquisition, 1410-6 R/W funding, 1410-4 Project analysis, 325-7 Project approval, 340-5 Project definition phase Environmental Review Summary (ERS), 330-7 Project environmental matrix, 240-9 Project summary, 150-9 Project Type, 325-2 Project types, 340-2 Project types and permits, 240-7 bridge deck rehabilitation, 240-8 bridge replacement, 240-7 bridge scour countermeasures, 240-8 bridge seismic retrofit, 240-8 existing bridge widening, 240-8 new special structures, 240-8 other bridge structures, 240-8 special bridge repair, 240-8 steel bridge painting, 240-8 Proprietary items, 720-8 impact attenuator, 720-8 irrigation, 1330-1 retaining wall design process, 1130-28, 1130-29 retaining walls, design, 1130-9 retaining walls options, 1130-18 traffic barriers, special, 710-18 traffic barrier terminals, 710-9, 710-10 proprietary items noise walls, 1140-4 Protective screening for highway structures, 1120-5 Public information, 810-1 Public Transportation and Intercity Rail Passenger Plan for Washington State, 120-9 Public Transportation and Rail Division, 120-8 Q Q Program, 340-2 QuadGuard cz impact attenuator, 720-5 QuadGuard Elite impact attenuator, 720-2, 720-4 QuadGuard impact attenuator, 720-2, 720-10 QuadTrend-350 impact attenuator, 720-1, 720-9 R Railroad crossings, 630-4 limited access, 1430-11 preemption, 850-11 R/W transactions, 1410-4 Ramp, 940-4 cross section, 940-5 design speed, 940-4 grade, 940-5 HOV direct access, 1055-1, 1055-5 HOV drop, 1055-4, 1055-11 HOV flyover, 1055-4, 1055-13 HOV ramp meter by pass, 1050-9, 1050-13, 1050-14 HOV T ramp, 1055-4, 1055-12 land widths, 1055-6 lane increases, 940-5 lane widths, 940-5 location, HOV direct access, 1055-3 meters, 940-6 shoulder widths, 1055-6 sight distance, 940-5 spacing, HOV direct access, 1055-3 superelevation, 642-1 superelevation runoff, 642-4 terminal intersections at crossroads, 940-9 terminal locations, HOV direct access, 1055-3 widths, 430-4 REACT 350 impact
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
attenuator, 720-3, 720-5, 720-12 Recoverable slope, 700-2 Recovery area, 700-2 Regional Transportation Improvement Program (RTIP), 120-12 Regional Transportation Planning Organizations (RTPO), 120-6 (RTPO),, 120-3 Regulatory traffic control strategies, 810-8 Reinforced slopes, 1130-1 geotechnical investigation, 510-8 Residential road approach, 920-2 Rest areas, 1030-1 geotechnical investigation, 510-7 Design Manual M 22-01 Index May 2006 Page 1 Retaining walls, 1130-1 aesthetics, 1130-4 anchored walls, 1130-2, 1130-24 classifications, 1130-1 constructibility, 1130-4 coordination with other design elements, 1130-4 cut and fill considerations, 1130-5 data submission for design, 1130-13 design principles, 1130-2 design requirements, 1130-2 drainage design, 1130-3 gabion walls, 1130-10, 1130-23 geotechnical and structural design, 1130-3 geotechnical investigation, 510-8 investigation of soils, 1130-3 metal bin walls, 1130-11, 1130-23 MSE gravity walls, 1130-2, 1130-22 nongravity cantilevered walls, 1130-2, 1130-24 nonpreapproved proprietary walls, 1130-12 nonstandard nonproprietary walls, 1130-12 nonstandard walls, 1130-9, 1130-13 preapproved proprietary walls, 1130-11 prefabricated modular gravity walls, 1130-2, 1130-23 proprietary wall systems, 1130-9 rigid gravity walls, 1130-1, 1130-24 rockeries, 1130-2, 1130-25 semigravity walls, 1130-2, 1130-6, 1130-24 settlement and deep foundation support considerations, 1130-6 standard walls, 1130-9, 1130-10 traffic barrier shape, 1130-3 wall and slope heights, 1130-7 Right-turn corners, 910-5 lanes, 910-8 pocket and taper, 910-8 Right of way, 1410-1 appraisal and acquisition, 1410-4 easements and permits, 1410-2 plans, 1410-1 programming for funds, 1410-4 special features, 1410-2 transactions, 1410-4 width, 440-9 Road approaches, 920-1, 1420-5 commercial, 920-3 design considerations, 920-2 design template, 920-2 drainage requirements, 920-4 farm, 920-3 location, 920-3 residential, 920-2 right of way, 1410-2 sight distance, 920-3 utility and special use, 920-3 Road closures, 810-5 Roadside, 1300-1 Roadside development, 1300-1 Roadsides bridge end slopes, 640-6 drainage ditches in embankment areas, 640-6 rock cuts, 640-4 side slopes, 640-4 stepped slopes, 640-6 Roadside safety, 700-1 definitions, 700-1 Documentation, 700-10 hazards, 700-3 Roadways, 640-2 shoulders, 640-2 traveled way cross slope, 640-2 turning roadway width, 641-1 turning
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
roadway widths, 640-2 widths, HOV facilities, 1050-8, 1050-11, 1050-12 Roadway sections, 640-6 Rock, investigation, 510-1 Rock anchors, 1130-2 Rock cuts, 640-4 geotechnical investigation, 510-10 Rock walls, 1130-2 Roundabouts, 915-1 access, 915-14 access control, modified, 1430-9 access control, partial, 1430-6 bicycles, 915-13 capacity analysis, 915-7 categories, 915-5 circulating roadway, 915-10 deflection, 915-9 Index Design Manual M 22-01 Page 1 May 2006 design clear zone, 915-13 design speed, 915-9 elements, 915-3 entry, 915-10 exit, 915-10 geometric design, 915-8 grades, 915-12 illumination, 915-14 inscribed diameter, 915-9 islands, 915-12 locations not normally recommended, 915-1 locations not recommended, 915-2 parking, 915-14 pavement marking, 915-13 pedestrians, 915-13 recommended locations, 915-1 sight distance, 915-11 signing, 915-13 superelevation, 915-12 transit facilities, 915-14 Route, bicycle, 1020-1, 1020-17 Route continuity, 940-4 Runoff, 1210-3 S Safety rest areas, 1030-1 SC&DI, 860-1 Scale sites, 1040-1 Scenic byway barrier, 710-4 Scoping phase Design Decisions Summary (DDS), 330-7 project summary, 330-6 SCRDI, 1055-10 Screening, 810-12 Section 4(f) lands, 210-7 Semidirectional interchange, 940-3 Sentre impact attenuator, 720-6, 720-16 Shared roadway, 1020-4, 1020-17 Shared use paths, 1020-2 Sheet piles, 1130-2 Shotcrete facing, 1130-7 Shoulders channelization, 910-9 cross slope, 640-2 driving for slow vehicles, 1010-4 function, 440-6 Slow-moving vehicle, 1010-4 turn-lanes, 910-9 turnouts, 1010-3 width, 440-5, 1055-6 Shy distance, 710-4 definition, 710-1 Side slopes, 640-4 Sidewalks, 1020-4 Sight distance, 920-3, 940-5, 940-7, 1055-5 bicycle, 1020-14 road approaches, 920-3 roundabouts, 915-11 Sight triangle, 910-11, 910-12 Signal geotechnical investigation, 510-6 intersection warning sign, 850-13 phasing, 850-4 supports, 850-13 warrants, 850-4 Signing, 820-1, 1055-9 bikeways, 1020-15, 1020-17 bridges, 820-3, 1120-3 bridges clearance, 1120-3 cantilever sign structures, 820-3 design components, 820-2 foundations, 820-3 geotechnical investigation, 510-6 ground mounted signs, 820-3 guide sign plan, 820-4 heights, 820-2 horizontal placement, 820-4 illumination, 820-3 lateral clearance, 820-2 lighting fixtures, 820-3 location, 820-2 longitudinal placement, 820-2 mileposts, 820-4 overhead installation, 820-3 posts, 820-3 roundabouts, 915-13
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
Design Manual M 22-01 Index May 2006 Page 1 service walkways, 820-4 structure mounted sign mountings, 820-3 vertical clearance, 820-4 Signing bridge clearance, 1120-3 Silt fence, 530-6 Single point (urban) interchange, 940-3 Single slope barrier, 710-15 Site data for structures, 1110-1 additional data for grade separations, 1110-3 additional data for waterway crossings, 1110-2 additional data for widenings, 1110-4 CAD files and supplemental drawings, 1110-1 highway-highway separation, 1110-3 highway-railroad separation, 1110-3 required data for all structures, 1110-1 Slope bridge end, 640-6 geotechnical investigation, 510-8 protection, 1120-5 protection at watercrossings, 1120-5 roadside, 640-4 roadways, 640-2 rock cuts, 640-4 shoulders, 640-2 side, 640-4 stabilization, 1350-2 stepped slopes, 640-6 traveled way, 640-2 Slow moving vehicle turnouts, 1010-3 Soil bioengineering, 1350-1 design responsibilities and considerations, 1350-3 streambank stabilization, 1350-2 upland slope stabilization, 1350-2 Soil nail walls, 1130-8 Soils, 510-1 investigation, 510-1 soldier piles, 1130-2 Spacing interchanges, 940-4 intersections, 910-4 Span wire, 850-14 Speed design, 440-4 Speed, design, 940-4, 1055-5 Speed change lanes, 910-9, 940-7, 940-8, 1055-6, 1055-7 Speed reduction, climbing lane warrant, 1010-2 Splitter island, 915-12 State Commute Trip Reduction Program, 120-8 State highways as city streets, 440-4 State Highway System Plan, 120-4 rural bicycle touring routes, 1020-2 urban bicycle projects, 1020-2 Statewide Planning., 120-3 Statewide Transportation Improvement Program (STIP), 120-5, 120-13 Statewide Transportation Planning, 120-1, 120-4 Steel backed timber guardrail, 710-18 Stepped slopes, 640-6 Stockpiles, R/W, 1410-2 Stone guardwalls, 710-18 stopping sight distance, 1055-5 Storage length, left-turn lane, 910-7 Strain poles steel, 850-14 timber, 850-14 Streambank stabilization, 1350-2 Striping. See Pavement markings Structural capacity, 1120-1 Structure width, 440-9 Study plan environmental, 220-2 value engineering, 315-2 Sundry sites right of way, 1410-2 source of materials, 510-1 Superelevation, 642-1 existing curves, 642-2 intersections, 642-3 rates for low-speed urban managed access highway, 642-2 rates for open highways and ramps, 642-1 roundabouts, 915-12 runoff for highway curves, 642-3
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
runoff for ramp curves, 642-4 shared use path, 1020-13 Surface Transportation Program, 120-7 Index Design Manual M 22-01 Page 16 May 2006 Surfacing materials, 510-1 investigation, 510-1 pavement structure, 520-1 surfacing report, 510-14 Surveying and mapping during design and development of the PS&E, 1440-1 during the project definition phase, 1440-1 Systems Analysis & Program Development Branch, 120-13 Systems Engineering for Intelligent Transportation Systems DM Supplement (12/30/2005) T Taper. See Lane transitions right-turn, 910-8 Taper, right-turn, 910-8 TAU-II impact attenuator, 720-2, 720-11 TDM Strategic Plan, 120-10 Temporary concrete barriers, 810-10 Temporary pavement markings, 810-12 Terrain classification, 440-3 Thrie beam. See Guardrail TMA, 810-10 TRACC impact attenuator, 720-5, 720-14 Traffic data collection, 860-2 islands, 910-9 lanes, 440-5 operations center (TOC), 860-2 signal design, 850-4 signal permit, 850-2 Traffic analysis intersections, 910-3 Traffic barrier, 700-2, 1055-9 Traffic control, 810-1 channelization, 910-6 Traffic control plans, 810-9 Traffic control signals, 850-1 control equipment, 850-8 crosswalks and pedestrians, 850-8 detection systems, 850-9 electrical design, 850-15 foundation design, 850-14 funding, construction, maintenance, & operation, 850-3 intersection design considerations, 850-7 preemption systems, 850-10 preliminary signal plan, 850-14 signal displays, 850-11 signal phasing, 850-4 signal supports, 850-13 signal warrants, 850-4 strain poles, 850-14 third party agreement signals, 850-3 Traffic Counts, 610-5 Traffic flow control, 860-3 HOV bypass, 860-4 ramp meters, 860-3 Traffic Impact Analysis Report, 610-9 Traffic interchanges, 940-1 collector distributor roads, 940-9 connections, 940-6, 940-9 design, 940-2 HOV direct access, 1055-1 lane balance, 940-6 on two-lane highways, 940-9 patterns, 940-3 plans, 940-10 ramp design speed, 940-4 ramp grade, 940-5 ramps, 940-4 ramp terminal intersections, 940-9 ramp widths, 940-5 sight distance, 940-5, 940-7 spacing, 940-4 weaving sections, 940-9 Traffic Systems Management Center (TSMC), 860-2 Transit passenger access, 1055-8 Transit benefit facilities, 1060-1 bus stops and pullouts, 1060-7 disabled accessibility, 1060-12 flyer stop access points, 1055-5 flyer stops, 1050-5, 1055-4
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
grades, 1060-11 intersection, 1060-12 lane widths, 1060-11 park and ride lots, 1060-1 park and ride stops, 1055-5 passenger amenities, 1060-10 Design Manual M 22-01 Index May 2006 Page 1 paving sections, 1060-11 priority preemption, 850-11 roundabouts, 915-14 stops, 1055-4 transfer/transit centers, 1060-7 vehicle characteristics, 1060-11 Transitions, pavement, 620-4 Transitions and connections, traffic barrier, 710-11 Transportation Demand Management Office, 120-9 Transportation equity act (TEA-21), 120-3 Transportation Facilities and Services of Statewide Significance, 120-6 Travel Demand Management Program (TDM), 120-11 Traveled way, 700-2 Traveled way cross slope, 640-2 Traveler services, 1030-1 TREND impact attenuator, 720-6, 720-16 Trip Generation, 610-5 Truck climbing lanes, 1010-2 escape ramps, 1010-4 weigh sites, 1040-1 Truck mounted attenuator, 720-6, 810-10 Tubular markers, 810-11 Turnbacks, limited access, 1430-11 Turning path template, 1060-26, 1060-28 Turning roadways, 641-1 Turning roadway widths, 640-2, 641-1 articulated buses, minimum, 1055-6 HOV facilities, 1050-8, 1050-12 Turnouts, 1010-3 Turnouts, slow-moving vehicle, 1010-3 Two-way left-turn lanes, 910-8 Type, approach, 1430-7 U U.S. Coast Guard, 1110-3 Uniformity of exit pattern, 940-4 Urban managed access highways, 440-18 Urban managed access highways superlevation, 642-2 Utilities limited access, 1430-5, 1430-7, 1430-10 R/W transactions, 1410-4 Utility road approach, 920-3 V Value Engineering (VE), 315-1 implementation phase, 315-4 job plan, 315-5 procedure, 315-1 selection phase, 315-1 team tools, 315-7 Variance, design, 325-7 Vegetation, 1320-1 Design guidelines, 1320-1 Operational, environmental and visual functions, 1320-1 Visual functions, 1320-1 Vehicle turning path template, 1060-26, 1060-28 Venture Washington, 860-1 Vertical alignment, 630-1 design controls, 630-1 length of grade, 630-2 maximum grades, 630-2 minimum grades, 630-2 minimum length of vertical curves, 630-2 structures, 630-2 Vertical clearance HOV direct access, 1055-7 new bridge, railroad, 1120-2 new bridge, roadway, 1120-2 pedestrian bridge, 1120-3 signing, bridge, 1120-3 structures, 1120-2, 1120-3 Vertical curbs, 440-9 Vertical Falsework Clearance for Bridges Over Highways DM Supplement (4/24/2006) W W-beam guardrail. See Guardrail Walls geotechnical investigation,
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
510-8 noise, 1140-2 retaining, 1130-1 Warrants, 850-4, 1010-2 Washington State Patrol median crossovers, 960-2 weigh sites, 1040-1 Index Design Manual M 22-01 Page 1 May 2006 Washingtons Transportation Plan (WTP), 120-4 Waste Sites, R/W, 1410-2 Water-filled barriers, 810-9 Weaving sections, 940-9 Weigh sites, 1040-1 federal participation, 1040-4 permanent facilities, 1040-2 planning, development, and responsibilities, 1040-1 portable facilities, 1040-3 shoulder sites, 1040-4 Wetlands, 210-7, 1210-2 Wide QuadGuard impact attenuator, 720-10 Wide REACT 350 impact attenuator, 720-12 Width HOV facilities, 1050-8, 1050-11, 1050-12 lane, 440-5 median, 440-7 right of way, 440-9 shoulder, 440-5 structure, 440-9 turning roadway, 641-1 Widths HOV direct access, 1055-6 Wildlife warning reflectors, 830-8 Wire fencing, 1460-3 Work zone classification, 810-2 intermediate-term stationary work zones, 810-2 long-term stationary work zones, 810-2 mobile work zones, 810-2 short-duration work zones, 810-2 short-term stationary work zones, 810-2 Work zone safety, 810-6 flaggers, 810-6 road users, 810-7 workers, 810-6 Work zone traffic control, 810-1 Work zone types, 810-3 crossover, 810-3 detour, 810-3 intermittent closure, 810-3 lane closure, 810-3 lane constriction, 810-3 median use, 810-3 multiple lane separation, 810-3 shared right of way, 810-3 shoulder use, 810-3 temporary bypass, 810-3 Z Zones, transition shared use path, 1020-12
|
{
"page_id": null,
"source": 7320,
"title": "from dpo"
}
|
Title: URL Source: Markdown Content: DISTRIBUTED ALGORITHMS 2010/2011 # Exercise Session 7 Terminating Reliable Broadcast November 15, 2010 ## Problem 1 Can we implement TRB with the eventually perfect failure detector P , if we assume that at least one process can crash? See Solution 6.10 in the book. ## Problem 2 Show that P is the weakest failure detector for Group Membership. In order to show that P is the weakest failure detector for Group Membership, we need to show that: • P can be used to implement Group Membership. • Group Membership can be used to implement P.The first direction stems directly from the Group Membership implementation in the class. For the second direction, we assume that all processes run Group Membership algorithm. Whenever a new view is installed, all processes that are freshly removed from the view are added to the suspected set. This approach satisfies both Strong Completeness and Strong Accuracy of P, directly from the corresponding properties of Group Membership. The failure detector D is weakest for solving some problem A (e.g., Consensus or NBAC) if D provides the smallest amount of information about failures that allows to solve A. 1/1
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
Title: URL Source: Markdown Content: # Failure Detection vs Group Membership in Fault-Tolerant Distributed Systems: Hidden Trade-Offs Andr´ e Schiper Ecole Polytechnique F´ ed´ erale de Lausanne (EPFL) 1015 Lausanne, Switzerland andre.schiper@epfl.ch Abstract. Failure detection and group membership are two important compo-nents of fault-tolerant distributed systems. Understanding their role is essential when developing efficient solutions, not only in failure-free runs, but also in runs in which processes do crash. While group membership provides consistent in-formation about the status of processes in the system, failure detectors provide inconsistent information. This paper discusses the trade-offs related to the use of these two components, and clarifies their roles using three examples. The first example shows a case where group membership may favourably be replaced by a failure detection mechanism. The second example illustrates a case where group membership is mandatory. Finally, the third example shows a case where nei-ther group membership nor failure detectors are needed (they may be replaced by weak ordering oracles). ## 1 Introduction Fault-tolerance in distributed systems may be achieved by replicating critical compo-nents. Although this idea is easily understood, the implementation of replication leads to difficult algorithmic problems. A distributed algorithm requires the specification of a system model. Two main models have been proposed: the synchronous model and the asynchronous model. The synchronous model assumes (1) a known bound on the trans-mission delay of messages, and (2) a known bound on the relative speed of processes — while the slowest process performs one step, the fastest process performs at most k steps where k is known). The asynchronous system does not assume any bound on the transmission delay of messages, and on the relative speed of processes. Obviously, the asynchronous model is more general. If some algorithm A is proven correct in the most general model (e.g.,
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
in the asynchronous model), A is also correct in a more re-stricted model (e.g. in the synchronous model). Clearly, it is advantageous to develop algorithms for the most general system model. Unfortunately, it has been proven that a very basic fault-tolerant problem, the con-sensus problem, cannot be solved by a deterministic algorithm in the asynchronous model when a single process may crash . The same problem may be solved by a deterministic algorithm in the synchronous system model. However, the synchronous system model requires that bounds be defined, which leads to a dilemma. If the bounds H. Hermanns and R. Segala (Eds.): PAPM-PROBMIV 2002, LNCS 2399, pp. 1–15, 2002. c© Springer-Verlag Berlin Heidelberg 2002 2 Andr´ e Schiper are chosen too small, they may be violated: in this case, the algorithm might behave erroneously. If the bound is too large, this has a negative impact on the performance of the algorithm if there is a crash: the crash detection time will be long, and the algorithm will be blocked in the meantime. Two other system models have been defined, which are between the asynchronous and the synchronous system models: the partially synchronous system model [ 11,14] and the asynchronous model augmented with failure detectors (which we will simply refer to as the failure detector model) . 1 Consensus is solvable in these two system models. The partially synchronous model assumes that bounds exist, but they are not known and hold only eventually. The failure detector model specifies the properties with regard to failure detection in terms of two properties: completeness and accuracy .Completeness specifies the behaviour of the failure detectors with respect to a crashed process. Accuracy specifies the behaviour of failure detectors with respect to correct processes. For example, the ♦S failure detector is defined (1) by strong completeness
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
—which requires that each faulty process is eventually suspected forever by each correct process — and (2) by eventual weak accuracy — which requires that eventually there exists some correct process that is no longer suspected by any correct process. The failure detector model has allowed a very important result to be established: ♦S is the weakest failure detector that allows us to solve consensus . The results for failure detectors, and other work performed over the last 10 years, have contributed to providing a good understanding of the algorithms related to repli-cation, e.g., consensus, atomic broadcast, group membership. The main open problem that remains is understanding the various algorithms from a quantitative point of view. This means not only comparing the cost of these algorithms in failure-free runs, but also in runs with process crashes. For crash detection, most existing infrastructures rely on a group membership service, whereas algorithmic papers rely on failure detectors. As shown below, this has an important impact on performance, and leads to the following questions: when is a membership service really needed, and when is a failure detection mechanism preferable? Before addressing these questions, Section 2 introduces the group membership prob-lem, and discusses solutions to this problem. Section 3 illustrates a case where group membership can favourably be replaced by a failure detection mechanism. However, failure detection alone is not enough: Section 4 gives an example where membership is necessary. Finally, Section 5 shows that it is sometimes possible to do without failure detection and group membership. Section 6 concludes the paper. ## 2 The Group Membership Problem 2.1 Specification Roughly speaking, a group membership service manages the formation and mainte-nance of a set of processes called a group . The successive memberships of a group are called views , and the event by
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
which a new is provided to a process is called the install event. A process may leave the group as a result of an explicit leave request
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
Title: The Weakest Failure Detector for Genuine Atomic Multicast URL Source: Markdown Content: # The Weakest Failure Detector for Genuine Atomic Multicast # Pierre Sutra # Telecom SudParis, Palaiseau, France Abstract Atomic broadcast is a group communication primitive to order messages across a set of distributed processes. Atomic multicast is its natural generalization where each message m is addressed to dst (m), a subset of the processes called its destination group. A solution to atomic multicast is genuine when a process takes steps only if a message is addressed to it. Genuine solutions are the ones used in practice because they have better performance. Let G be all the destination groups and F be the cyclic families in it, that is the subsets of G whose intersection graph is hamiltonian. This paper establishes that the weakest failure detector to solve genuine atomic multicast is μ = ( ∧g,h ∈G Σg∩h) ∧ (∧g∈G Ωg ) ∧ γ, where ΣP and ΩP are the quorum and leader failure detectors restricted to the processes in P , and γ is a new failure detector that informs the processes in a cyclic family f ∈ F when f is faulty. We also study two classical variations of atomic multicast. The first variation requires that message delivery follows the real-time order. In this case, μ must be strengthened with 1g∩h, the indicator failure detector that informs each process in g ∪ h when g ∩ h is faulty. The second variation requires a message to be delivered when the destination group runs in isolation. We prove that its weakest failure detector is at least μ ∧ (∧g,h ∈G Ωg∩h). This value is attained when F = ∅. 2012 ACM Subject Classification Theory of computation → Distributed computing models; Software and its engineering → Distributed
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
systems organizing principles; General and reference → Reliability Keywords and phrases Failure Detector, State Machine Replication, Consensus Digital Object Identifier 10.4230/LIPIcs.DISC.2022.35 Related Version Extended Version : # 1 Introduction Context. Multicast is a fundamental group communication primitive used in modern computing infrastructures. This primitive allows to disseminate a message to a subset of the processes in the system, its destination group. Implementations exist over point-to-point protocols such as the Internet Protocol. Multicast is atomic when it offers the properties of atomic broadcast to the multicast primitive: each message is delivered at most once, and delivery occurs following some global order. Atomic multicast is used to implement strongly consistent data storage [4, 11, 36, 32]. It is easy to see that atomic multicast can be implemented atop atomic broadcast. Each message is sent through atomic broadcast and delivered where appropriate. Such a naive approach is however used rarely in practice because it is inefficient when the number of destination groups is large [ 31 , 35 ]. To rule out naive implementations, Guerraoui and Schiper [ 25 ] introduce the notion of genuineness. An implementation of atomic multicast is genuine when a process takes steps only if a message is addressed to it. Existing genuine atomic multicast algorithms that are fault-tolerant have strong synchrony assumptions on the underlying system. Some protocols (such as [ 34 ]) assume that a perfect failure detector is available. Alternatively, a common assumption is that the destination groups are decomposable into disjoint groups, each of these behaving as a logically correct entity. Such an assumption is a consequence of the impossibility result established in [ 25 ]. > ©Pierre Sutra; licensed under Creative Commons License CC-BY 4.0 36th International Symposium on Distributed Computing (DISC 2022). Editor: Christian Scheideler; Article No. 35; pp. 35:1–35:19 Leibniz
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
International Proceedings in Informatics > Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany 35:2 The Weakest Failure Detector for Genuine Atomic Multicast > Table 1 About the weakest failure detector for atomic multicast. (√√ = strongly genuine ) > Genuiness Order Weakest > ×Global Ω∧Σ[8, 15] > √·/∈ U 2 > ··≤P > ··μ§5, §4 > ·Strict μ∧(∧g,h ∈G 1g∩h)§6.1 > ·Pairwise (∧g,h ∈G Σg∩h)∧(∧g∈G Ωg)§7 > √√ Global if F=∅then μ∧(∧g,h ∈G Ωg∩h)§6.2 > else ≥μ∧(∧g,h ∈G Ωg∩h) This result states that genuine atomic multicast requires some form of perfect failure detection in intersecting groups. Consequently, almost all protocols published to date (e.g., [30, 17, 20, 10, 29, 13]) assume the existence of such a decomposition. Motivation. A key observation is that the impossibility result in [ 25 ] is established when atomic multicast allows a message to be disseminated to any subset of the processes. However, where there is no such need, weaker synchrony assumptions may just work. For instance, when each message is addressed to a single process, the problem is trivial and can be solved in an asynchronous system. Conversely, when every message is addressed to all the processes in the system, atomic multicast boils down to atomic broadcast, and thus ultimately to consensus. Now, if no two groups intersect, solving consensus inside each group seems both necessary and sufficient. In this paper, we further push this line of thought to characterize the necessary and sufficient synchrony assumptions to solve genuine atomic multicast. Our results are established in the unreliable failure detectors model [ 9, 18 ]. A failure detector is an oracle available locally to each process that provides information regarding the speed at which the other processes are taking steps. Finding the weakest failure detector to solve a given problem is a central
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
question in distributed computing literature [ 18 ]. In particular, the seminal work in [ 8] shows that a leader oracle ( Ω) is the weakest failure detector for consensus when a majority of processes is correct. If any processes might fail, then a quorum failure detector ( Σ) is required in addition to Ω . A failure detector is realistic when it cannot guess the future. In [ 14 ], the authors prove that the perfect failure detector ( P ) is the weakest realistic failure detector to solve consensus. Building upon this result, Schiper and Pedone [ 34 ] shows that P is sufficient to implement genuine atomic multicast. However, P is the weakest only when messages are addressed to all the processes in the system. The present paper generalizes this result and the characterization given in [ 25 ] (see Table 1). It establishes the weakest failure detector to solve genuine atomic multicast for any set of destination groups. Primer on the findings. Let G be all the destination groups and F be the cyclic families in it, that is the subsets of G whose intersection graph is hamiltonian. This paper shows that the weakest failure detector to solve genuine atomic multicast is μ = ( ∧g,h ∈G Σg∩h)∧(∧g∈G Ωg )∧γ,where ΣP and ΩP are the quorum and leader failure detectors restricted to the processes in P , and γ is a new failure detector that informs the processes in a cyclic family f ∈ F when f is faulty. Our results regarding γ are established wrt. realistic failure detectors. This paper also studies two classical variations of the atomic multicast problem. The strict variation requires that message delivery follows the real-time order. In this case, we prove that μ must be strengthen with 1g∩h, the indicator
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
failure detector that informs each P. Sutra 35:3 process in g ∪ h when g ∩ h is faulty. The strongly genuine variation requires a message to be delivered when its destination group runs in isolation. In that case, the weakest failure detector is at least μ ∧ (∧g,h ∈G Ωg∩h). This value is attained when F = ∅. Outline of the paper. §2 introduces the atomic multicast problem and the notion of genuineness. We present the candidate failure detector in §3. §4 proves that this candidate is sufficient. Its necessity is established in §5. §6 details the results regarding the two variations of the problem. We cover related work and discuss our results in §7. §8 closes this paper. Due to space constraints, all the proofs are deferred to the extended version . # 2 The Atomic Multicast Problem 2.1 System Model In [ 9 ], the authors extend the usual model of asynchronous distributed computation to include failure detectors. The present paper follows this model with the simplifications introduced in [23, 22]. This model is recalled in . # 2.2 Problem Definition Atomic multicast is a group communication primitive that allows to disseminate messages between processes. This primitive is used to build transactional systems [ 11 , 36 ] and partially-replicated (aka., sharded) data stores [ 17 , 32 ]. In what follows, we consider the most standard definition for this problem [ 4 , 26 , 12 ]. In the parlance of Hadzilacos and Toueg [ 26 ], it is named uniform global total order multicast. Other variations are studied in §6. Given a set of messages M, the interface of atomic multicast consists of operations multicast (m) and deliver (m), with m ∈ M . Operation multicast (m) allows a process to multicast a message m
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
to a set of processes denoted by dst (m). This set is named the destination group of m. When a process executes deliver (m), it delivers message m, typically to an upper applicative layer. Consider two messages m and m′ and some process p ∈ dst (m) ∩ dst (m′). Relation m p 7→ m′ captures the local delivery order at process p. This relation holds when, at the time p delivers m, p has not delivered m′. The union of the local delivery orders gives the delivery order , that is 7 →= ∪p∈P > p 7→. The runs of atomic multicast must satisfy: (Integrity) For every process p and message m, p delivers m at most once, and only if p belongs to dst (m) and m was previously multicast. (Termination) For every message m, if a correct process multicasts m, or a process delivers m, eventually every correct process in dst (m) delivers m. (Ordering) The transitive closure of 7 → is a strict partial order over M.Integrity and termination are two common properties in group communication literature. They respectively ensure that only sound messages are delivered to the upper layer and that the communication primitive makes progress. Ordering guarantees that the messages could have been received by a sequential process. A common and equivalent rewriting of this property is as follows: (Ordering) Relation 7 → is acyclic over M. D I S C 2 0 2 2 35:4 The Weakest Failure Detector for Genuine Atomic Multicast If the sole destination group is P, that is the set of all the processes, the definition above is the one of atomic broadcast. In what follows, G ⊆ 2P is the set of all the destinations groups, i.e., G = {g : ∃m ∈ M . g = dst
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
(m)}. For some process p, G(p) denotes the destination groups in G that contain p. Two groups g and h are intersecting when g ∩ h̸ = ∅. What can be sent and to who. The process that executes multicast (m) is the sender of m, denoted src (m). As usual, we consider that processes disseminate different messages (i.e., src is a function). A message holds a bounded payload payload (m), and we assume that atomic multicast is not payload-sensitive. This means that for every message m, and for every possible payload x, there exists a message m′ ∈ M such that payload (m′) = x, dst (m′) = dst (m) and src (m′) = src (m). Dissemination model. In this paper, we consider a closed model of dissemination. This means that to send a message to some group g, a process must belong to it (i.e., src (m) ∈ dst (m)). In addition, we do not restrict the source of a message. This translates into the fact that for every message m, for every process p in dst (m), there exists a message m′ with dst (m) = dst (m′) and src (m′) = p. Under the above set of assumptions, the atomic multicast problem is fully determined by the destination groups G. # 2.3 Genuineness At first glance, atomic multicast boils down to the atomic broadcast problem: to disseminate a message it suffices to broadcast it, and upon reception only messages addressed to the local machine are delivered. With this approach, every process takes computational steps to deliver every message, including the ones it is not concerned with. As a consequence, the protocol does not scale [ 31 , 35 ], even if the workload is embarrassingly parallel (e.g., when the destinations groups are pairwise disjoint). Such a
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
strategy defeats the core purpose of atomic multicast and is thus not satisfying from a performance perspective. To rule out this class of solutions, Guerraoui and Schiper [ 25 ]introduce the notion of genuine atomic multicast. These protocols satisfy the minimality property defined below. (Minimality) In every run R of A, if some correct process p sends or receives a (non-null) message in R, there exists a message m multicast in R with p ∈ dst (m).All the results stated in this paper concern genuine atomic multicast. To date, this is the most studied variation for this problem (see, e.g., [30, 20, 10]). # 3 The Candidate Failure Detector This paper characterizes the weakest failure detector to solve genuine atomic multicast. Below, we introduce several notions related to failure detectors then present our candidate. Family of destination groups. A family of destination groups is a set of (non-repeated) destination groups f = ( gi)i. For some family f, cpaths (f) are the closed paths in the intersection graph of f visiting all its destination groups. 1 Family f is cyclic when its intersection graph is hamiltonian, that is when cpaths (f) is non-empty. A cyclic family f is faulty at time t when every path π ∈ cpaths (f) visits an edge (g, h ) with g ∩ h faulty at t. > 1The intersection graph of a family of sets (Si)iis the undirected graph whose vertices are the sets Si,and such that there is an edge linking Siand Sjiff Si∩Sj̸=∅. P. Sutra 35:5 # p1 p2 # p3 # p4p5 > (a) g1 g2 g3 {p2} {p1} {p3} > (b) g1 g3 g4 {p1} {p1} {p1, p 4} > (c) > Figure 1 From left to right: the four groups g1,g2,g3and g4, and the intersection graphs of the two
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
cyclic families f={g1, g 2, g 3}and f′={g1, g 3, g 4}. In what follows, F denotes all the cyclic families in 2G . Given a destination group g, F(g) are the cyclic families in F that contain g. For some process p, F(p) are the cyclic families f such that p belongs to some group intersection in f (that is, ∃g, h ∈ f. p ∈ g ∩ h). To illustrate the above notions, consider Figure 1. In this figure, P = {p1, . . . , p 5} and we have four destination groups: g1 = {p1, p 2}, g2 = {p2, p 3}, g3 = {p1, p 3, p 4} and g4 = {p1, p 4, p 5}. The intersection graphs of f = {g1, g 2, g 3} and f′ = {g1, g 3, g 4} are depicted respectively in Figures 1b and 1c. These two families are cyclic. This is also the case of f′′ = G = {g1, g 2, g 3, g 4} whose intersection graph is the union of the two intersection graphs of f and f′. This family is faulty when g2 ∩ g1 = {p2} fails. Group g2 belongs to two cyclic families, namely F(g2) = {f, f′′ }. Process p1 belongs to all cyclic families, that is F(p1) = F.Differently, since p5 is part of no group intersection, F(p5) = ∅. Failure detectors of interest. Failure detectors are grouped into classes of equivalence that share common computational power. Several classes of failure detectors have been proposed in the past. This paper makes use of two common classes of failure detectors, Σ and Ω,respectively introduced in [ 15 ] and [ 8]. We also propose a new class γ named the cyclicity failure detector . All these classes are detailed
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
below. The quorum failure detector ( Σ) captures the minimal amount of synchrony to implement an atomic register. When a process p queries at time t a detector of this class, it returns a non-empty subset of processes Σ( p, t ) ⊆ P such that: (Intersection) ∀p, q ∈ P . ∀t, t ′ ∈ N. Σ( p, t ) ∩ Σ( q, t ′)̸ = ∅ (Liveness) ∀p ∈ Correct . ∃τ ∈ N. ∀t ≥ τ. Σ( p, t ) ⊆ Correct The first property states that the values of any two quorums taken at any times intersect. It is used to maintain the consistency of the atomic register. The second property ensures that eventually only correct processes are returned. Failure detector Ω returns an eventually reliable leader [ 16 ]. In detail, it returns a value Ω( p, t ) ∈ P satisfying that: (Leadership) Correct ̸ = ∅ ⇒ (∃l ∈ Correct . ∀p ∈ Correct . ∃τ ∈ N. ∀t ≥ τ. Ω( p, t ) = l)Ω is the weakest failure detector to solve consensus when processes have access to a shared memory. For message-passing distributed systems, Ω ∧ Σ is the weakest failure detector. The cyclicity failure detector ( γ) informs each process of the cyclic families it is currently involved with. In detail, failure detector γ returns at each process p a set of cyclic families f ∈ F (p) such that: (Accuracy) ∀p ∈ P . ∀t ∈ N. (f ∈ F (p) ∧ f /∈ γ(p, t )) ⇒ f faulty at t (Completeness) ∀p ∈ Correct . ∀t ∈ N. (f ∈ F (p) ∧ f faulty at t) ⇒ ∃ τ ∈ N. ∀t′ ≥ τ. f /∈ γ(p, t ′) D I S C 2 0
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
2 2 35:6 The Weakest Failure Detector for Genuine Atomic Multicast Accuracy ensures that if some cyclic family f is not output at p and p belongs to it, then f is faulty at that time. Completeness requires that eventually γ does not output forever a faulty family at the correct processes that are part of it. Hereafter, γ(g) denotes the groups h such that g ∩ h̸ = ∅ and g and h belong to a cyclic family output by γ.To illustrate the above definitions, we may consider again the system depicted in Figure 1. Let us assume that Correct = {p1, p 4, p 5}. The quorum failure detector Σ can return g1 or g3, then g4 forever. Failure detector Ω may output any process, then at some point in time, one of the correct processes (e.g., p1) ought to be elected forever. At processes p1, γ returns initially {f, f′, f′′ }. Then, once families f and f′′ are faulty – this should happen as p2 is faulty – the output eventually stabilizes to {f′}. When this happens, γ(g1) = {g3, g 4}. Conjunction of failure detectors. We write C ∧ D the conjunction of the failure detectors C and D [23 ]. For a failure pattern F , failure detector C ∧ D returns a history in D(F ) × C(F ). Set-restricted failure detectors. For some failure detector D, DP is the failure detector obtained by restricting D to the processes in P ⊆ P . This failure detector behaves as D for the processes p ∈ P , and it returns ⊥ at p / ∈ P . In detail, let F ∩ P be the failure pattern F obtained from F by removing the processes outside P , i.e., (F ∩ P )(
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
t) = F (t) ∩ P . Then, DP (F ) equals D(F ∩ P ) at p ∈ P , and the mapping p × N → ⊥ elsewhere. To illustrate this definition, Ω{p} is the trivial failure detector that returns p at process p. Another example is given by Σ{p1,p 2} which behaves as Σ over P = {p1, p 2}. The candidate. Our candidate failure detector is μG = ( ∧g,h ∈G Σg∩h) ∧ (∧g∈G Ωg ) ∧ γ.When the set of destinations groups G is clear from the context, we shall omit the subscript. # 4 Sufficiency This section shows that genuine atomic multicast is solvable with the candidate failure detector. A first observation toward this result is that consensus is wait-free solvable in g using Σg ∧ Ωg . Indeed, Σg permits to build shared atomic registers in g [15 ]. From these registers, we may construct an obstruction-free consensus and boost it with Ωg [ 24 ]. Thus, any linearizable wait-free shared objects is implementable in g [27 ]. Leveraging these observations, this section depicts a solution built atop (high-level) shared objects. Below, we first introduce group sequential atomic multicast (§4.1). From a computability perspective, this simpler variation is equivalent to the common atomic multicast problem. This is the variation that we shall implement hereafter. We then explain at coarse grain how to solve genuine atomic multicast in a fault-tolerant manner using the failure detector μ (§4.2). Further, the details of our solution are presented and its correctness informally argued (§4.3). # 4.1 A simpler variation Group sequential atomic multicast requires that each group handles its messages sequentially. In detail, given two messages m and m′ addressed to the same group, we write m ≺ m′ when src (m′) delivers m before it multicasts
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
m′. This variation requires that if m and m′ are multicast to the same group, then m ≺ m′, or the converse, holds. Proposition 1 below establishes that this variation is as difficult as (vanilla) atomic multicast. Building upon this insight, this section depicts a solution to group sequential atomic multicast using failure detector μ.P. Sutra 35:7 ▶ Proposition 1. Group sequential atomic multicast is equivalent to atomic multicast. # 4.2 Overview of the solution First of all, we observe that if the groups are pairwise disjoint, it suffices that each group orders the messages it received to solve atomic multicast. To this end, we use a shared log LOG g per group g. Then, consider that the intersection graph of G is acyclic, i.e., F is empty, yet groups may intersect. In that case, it suffices to add a deterministic merge procedure in each group intersection, for instance, using a set of logs LOG g∩h when g ∩ h̸ = ∅.Now, to solve the general case, cycles in the order built with the shared logs must be taken into account. To this end, we use a fault-tolerant variation of Skeen’s solution [ 5, 21 ]: in each log, the message is bumped to the highest initial position it occupies in all the logs. In the original algorithm [ 5], as in many other approaches (e.g., [ 20 , 10 ]), such a procedure is failure-free, and processes simply agree on the final position (aka., timestamp) of the message in the logs. In contrast, our algorithm allows a disagreement when the cyclic family becomes faulty. This disagreement is however restricted to different logs, as in the acyclic case. # 4.3 Algorithm Algorithm 1 depicts a solution to (group sequential) genuine atomic multicast using failure detector μ. To the best of
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
our knowledge, this is only algorithm with [ 34 ] that tolerates arbitrary failures. Algorithm 1 is composed of a set of actions. An action is executable once its preconditions ( pre: ) are true. The effects ( eff: ) of an action are applied sequentially until it returns. Algorithm 1 uses a log per group and per group intersection. Logs are linearizable, long-lived and wait-free. Their sequential interface is detailed below. Logs. A log is an infinite array of slots. Slots are numbered from 1. Each slot contains one or more data items. A datum d is at position k when slot k contains it. This position is obtained through a call to pos (d); 0 is returned if d is absent. A slot k is free when it contains no data item. In the initial state, every slot is free. The head of the log points to the first free slot after which there are only free slots (initially, slot 1). Operation append (d) inserts datum d at the slot pointed by the head of the log then returns its position. If d is already in the log, this operation does nothing. When d is in the log, it can be locked with operation bumpAndLock (d, k ). This operation moves d from its current slot l to slot max (k, l ), then locks it. Once locked, a datum cannot be bumped anymore. Operation locked (d) indicates if d is locked in the log. We write d ∈ L when datum d is at some position in the log L. A log implies an ordering on the data items it contains. When d and d′ both appear in L, d < L d′ is true when the position of d is lower than the position of d′,
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
or they both occupy the same slot and d < d ′, for some a priori total order ( <) over the data items. Variables. Algorithm 1 employs two types of shared objects at a process. First, for any two groups h and h′ to which the local process belongs, Algorithm 1 uses a log LOG h∩h′ (line 2). Notice that, when h = h′, the log coincides with the log of the destination group h,i.e., LOG h. Second, to agree on the final position of a message, Algorithm 1 also employs consensus objects (line 3). Consensus objects are both indexed by messages and group families. Given some message m and appropriate family f, Algorithm 1 calls CONS m, f (lines 20 and 21). Two processes call the same consensus object at line 21 only if both parameters match. Finally, to store the status of messages addressed to the local process, Algorithm 1 also employs a mapping phase (line 4). A message is initially in the start phase, then it moves to pending (line 15), commit (line 24), stable (line 33) and finally the deliver (line 37) phase. Phases are ordered according to this progression. D I S C 2 0 2 2 35:8 The Weakest Failure Detector for Genuine Atomic Multicast Algorithm 1 Solving atomic multicast with failure detector μ – code at process p. 1: variables: 2: (LOG h∩h′ )h,h ′∈G (p) 3: (CONS m, f)m∈M ,f⊆G 4: phase [m] ← λm. start 5: multicast (m) := // g = dst (m) ∧ g ∈ G (p) 6: pre: phase [m] = start 7: eff: LOG g .append (m) 8: pending (m) := 9: pre: phase [m] = start 10: m ∈ LOG g 11: ∀m′ 2In the failure detector model, computability results can use any amount of
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
shared objects. D I S C 2 0 2 2 35:10 The Weakest Failure Detector for Genuine Atomic Multicast Algorithm 2 Emulating Σ∩g∈Gg – code at process p. > 1: variables: > 2: (Ag,x )g∈G,x ⊆g.p ∈x > 3: (Qg )g∈G ← λg. {g} > 4: (qr g )g∈G ← λg.g > 5: for all g ∈ G, x ⊆ g : p ∈ x do > 6: let m such that dst (m) = g ∧ payload (m) = p > 7: Ag,x .multicast (m) > 8: when Ag,x .deliver (−) > 9: Qg ← Qg ∪ { x} > 10: when query > 11: if p / ∈ ⋂ > g∈G g then > 12: return ⊥ > 13: for all g ∈ G do > 14: qr g ← choose arg max > y∈Qg rank (y) > 15: return (⋃ > g∈G qr g ) ∩ (⋂ > g∈G g) # 5 Necessity Consider some environment E, a failure detector D and an algorithm A that uses D to solve atomic multicast in E. This section shows that D is stronger than μ in E. To this end, we first use the fact that atomic multicast solves consensus per group. Hence μ is stronger than ∧g∈G (Ω g ∧ Σg ). §5.1 proves that D is stronger than Σg∩h for any two groups g, h ∈ G .Further, in §5.2, we establish that D is stronger than γ. This last result is established when D is realistic. The remaining cases are discussed in §7. # 5.1 Emulating Σg∩h Atomic multicast solves consensus in each destination group. This permits to emulate ∧g∈G Σg .However, for two intersecting groups g and h, Σg ∧ Σh is not strong enough to emulate Σg∩h.3 Hence, we must build the failure detector
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
directly from the communication primitive. Algorithm 2 presents such a construction. This algorithm can be seen as an extension of the work of Bonnet and Raynal [ 6] to extract Σk when k-set agreement is solvable. Algorithm 2 emulates Σ∩g∈Gg , where G ⊆ G is a set of at most two intersecting destination groups. At a process p, Algorithm 2 employs multiple instances of algorithm A. In detail, for every group g ∈ G and subset x of g, if process p belongs to x, then p executes an instance Ag,x (line 2). Variable Qg stores the responsive subsets of g, that is the sets x ⊆ g for which Ag,x delivers a message. Initially, this variable is set to {g}.Algorithm 2 uses the ranking function defined in [ 6]. For some set x ⊆ P , function rank (x) outputs the rank of x. Initially, all the sets have rank 0. Function rank ensures a unique property: a set x is correct if and only if it ranks grows forever. To compute this function, processes keep track of each others by exchanging (asynchronously) “alive” messages. At a process p, the number of “alive” messages received so far from q defines the rank of q. The rank of a set is the lowest rank among all of its members. > 3The two detectors may return forever non-intersecting quorums. P. Sutra 35:11 At the start of Algorithm 2, a process atomic multicasts its identity for every instance Ag,x it is executing (line 7). When, Ag,x delivers a process identity, x is added to variable Qg (line 9). Thus, variable Qg holds all the instances Ag,x that progress successfully despite that g \ x do not participate. From this set, Algorithm 2 computes the most responsive quorum using the ranking function
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
(line 14). As stated in Theorem 2 below, these quorums must intersect at any two processes in ∩g∈Gg. ▶ Theorem 2. Algorithm 2 implements Σ∩g∈Gg in E. # 5.2 Emulating γ Target systems. A process p is failure-prone in environment E when for some failure pattern F ∈ E, p ∈ Faulty (F ). By extension, we say that P ⊆ P is failure-prone when for some F ∈ E, P ⊆ Faulty (F ). A cyclic family f is failure-prone when one of its group intersections is failure-prone. Below, we consider that E satisfies that if a process may fail, it may fail at any time (formally, ∀F ∈ E. ∀p ∈ Faulty (F ). ∃F ′ ∈ E. ∀t ∈ N. ∀t′ < t. F ′(t′) = F (t′) ∧ F ′(t) = F (t) ∪ { p}). We also restrict our attention to realistic failure detectors, that is they cannot guess the future . Additional notions. Consider a cyclic family f. Two closed paths π and π′ in cpaths (f) are equivalent, written π ≡ π′, when they visit the same edges in the intersection graph. A closed path π in cpaths (f) is oriented. The direction of π is given by dir (π). It equals 1 when the path is clockwise, and −1 otherwise (for some canonical representation of the intersection graph). To illustrate these notions, consider family f in Figure 1b. The sequence π = g3g1g2g3 is a closed path in its intersection graph, with |π| = 4 and π = π[|π| − 1] = g3.The direction of this path is 1 since it is visiting clockwise the intersection graph of f in the figure. Path π is equivalent to the path π′ = g1g3g2g1 which visits f in the converse direction. Construction. We emulate
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
failure detector γ in Algorithm 3. For each closed path π ∈ cpaths (f) with π ∩ π failure-prone in E, Algorithm 3 maintains two variables: an instance Aπ of the multicast algorithm A, and a flag failed [π]. Variable Aπ is used to detect when a group intersection visited by π is faulty. It this happens, the flag failed [π] is raised. When for every path π ∈ cpaths (f), some path equivalent to π is faulty, Algorithm 3 ceases returning the family f (line 16). In Algorithm 3, for every path π ∈ cpaths (f), the processes in π ∩ π multicast their identities to π using instance Aπ (lines 4 and 5). In this instance of A, all the processes in f but the intersection π ∩ π[|π| − 2] participate (line 2). As the path is closed, this corresponds to the intersection with the last group preceding the first group in the path. When p ∈ π[i] ∩ π[i + 1] delivers a message (−, i ), it signals this information to the other members of the family (line 9). Then, p multicasts its identity to π[i + 1] (line 10). This mechanism is repeated until the antepenultimate group in the path is reached (line 8). When such a situation occurs, the flag failed [π] is raised (line 12). This might also happen earlier when a message is received for some path π′ equivalent to π and visiting f in the converse direction (line 13). Below, we claim that Algorithm 3 is a correct emulation of failure detector γ. ▶ Theorem 3. Algorithm 3 implements γ in E. D I S C 2 0 2 2 35:12 The Weakest Failure Detector for Genuine Atomic Multicast > Algorithm 3 Emulating γ– code at process p. > 1:
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
variables: > 2: (Aπ)π// ∀f∈ F (p).∀π∈cpaths (f). p / ∈π ∩π[|π| − 2] > 3: failed [π]←λπ. false > 4: for all Aπ:p∈π ∩π do > 5: Aπ.multicast (p, 0) to π > 6: signal (π, i ):= > 7: pre: Aπ.deliver (−, i ) > 8: i 9: eff: send (π, i )to f > 10: Aπ.multicast (p, i + 1) to π[i+ 1] > 11: update (π):= > 12: pre: ∃π′≡π. rcv (π, j )∧ ∨ j=|π| − 3 > 13: ∨(rcv (π′,0) ∧π[j] = π′ ∧dir (π) = −dir (π′)) > 14: eff: failed [π]←true > 15: when query > 16: return {f∈ F (p) : ∃π∈cpaths (f).∀π′≡π. failed [π′] = false } # 6 Variations This section explores two common variations of the atomic multicast problem. It shows that each variation has a weakest failure detector stronger than μ. The first variation requires messages to be ordered according to real time. This means that if m is delivered before m′ is multicast, no process may deliver m′ before m. In this case, we establish that the weakest failure detector must accurately detect the failure of a group intersection. The second variation demands each group to progress independently in the delivery of the messages. This property strengthens minimality because in a genuine solution a process may help others as soon as it has delivered a message. We show that the weakest failure detector for this variation permits to elect a leader in each group intersection. # 6.1 Enforcing real-time order Ordering primitives like atomic broadcast are widely used to construct dependable services [ 7 ]. The classical approach is to follow state-machine replication (SMR), a form of universal construction. In SMR, a service is defined by a deterministic state machine,
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
and each replica maintains its own local copy of the machine. Commands accessing the service are funneled through the ordering primitive before being applied at each replica on the local copy. SMR protocols must satisfy linearizability [ 28 ]. However, as observed in [ 3 ], the common definition of atomic multicast is not strong enough for this: if some command d is submitted after a command c get delivered, atomic multicast does not enforce c to be delivered before d,breaking linearizability. To sidestep this problem, a stricter variation must be used. Below, we define such a variation and characterize its weakest failure detector. # 6.1.1 Definition We write m ⇝ m′ when m is delivered in real-time before m′ is multicast. Atomic multicast is strict when ordering is replaced with: ( Strict Ordering ) The transitive closure of (7 → ∪ ⇝) is a strict partial order over M. Strictness is free when there is a single destination group. P. Sutra 35:13 > Algorithm 4 Emulating 1g∩h– code at process p∈g∪h. > 1: variables: > 2: B←if (p∈g\h)then Agelse if (p∈h\g)then Ahelse ⊥// Agand Ahare distinct instances of A > 3: failed ←false > 4: if B̸=⊥then > 5: B. multicast (p) > 6: wait until B. deliver (−) > 7: send (failed )to g∪h > 8: when rcv (failed ) > 9: failed ←true > 10: when query > 11: return failed Indeed, if p delivers m before q broadcasts m′, then necessarily m p 7→ m′. This explains why atomic broadcast does not mention such a requirement. In what follows, we prove that strict atomic multicast is harder than (vanilla) atomic multicast. # 6.1.2 Weakest failure detector Candidate. For some (non-empty) group of processes P , the indicator failure detector 1P indicates if all the processes in
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
P are faulty or not. In detail, this failure detector returns a boolean which ensures that: (Accuracy) ∀p ∈ P . ∀t ∈ N. 1P (p, t ) ⇒ P ⊆ F (t) (Completeness) ∀p ∈ Correct . ∀t ∈ N. P ⊆ F (t) ⇒ ∃ τ ∈ N. ∀t′ ≥ τ. 1P (p, t ′) For simplicity, we write 1g∩h the indicator failure detector restricted to the processes in g ∪ h (that is, the failure detector 1g∩hg∪h). This failure detector informs the processes outside g ∩ h when the intersection is faulty. Notice that for the processes in the intersection, 1g∩h does not provide any useful information. This comes from the fact that simply returning always true is a valid implementation at these processes. Our candidate failure detector is μ ∧ (∧g,h ∈G 1g∩h). One can establish that ∧g,h ∈G 1g∩h is stronger than γ (see Proposition 4 below). As a consequence, this failure detector can be rewritten as (∧g,h ∈G Σg∩h ∧ 1g∩h) ∧ (∧g∈G Ωg ). ▶ Proposition 4. ∧g,h ∈G 1g∩h ≤ γ Necessity. An algorithm to construct 1g∩h is presented in Algorithm 4. It relies on an implementation A of strict atomic multicast that makes use internally of some failure detector D. Proposition 5 establishes the correctness of such a construction. ▶ Proposition 5. Algorithm 4 implements 1g∩h. Sufficiency. The solution to strict atomic multicast is almost identical to Algorithm 1. The only difference is at line 32 when a message moves to the stable phase. Here, for every destination group h with h ∩ g̸ = ∅, a process waits either that 1g∩h returns true , or that a tuple (m, h ) appears in LOG g . From Proposition 4, we know that the indicator failure detector 1g∩h provides a better
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
information than γ regarding the correctness of g ∩ h. As a consequence, the modified algorithm solves (group sequential) atomic multicast. D I S C 2 0 2 2 35:14 The Weakest Failure Detector for Genuine Atomic Multicast Now, to see why such a solution is strict, consider two messages m and m′ that are delivered in a run, with g = dst (m) and h = dst (m′). We observe that when m′ ⇝ m or m′ 7 → m, m′ is stable before m, from which we deduce that strict ordering holds. With more details, in the former case ( m′ ⇝ m), this comes from the fact that to be delivered a message must be stable first (line 35). In the later ( m′ 7 → m), when message m is stable at some process p, p must wait a message (m, h ) in LOG g , or that 1g∩h returns true . If (m, h ) is in LOG g , then line 29 was called before by some process q. Because both messages are delivered and m′ 7 → m, m′ must precedes m in LOG g∩h. Thus the precondition at line 28 enforces that m′ is stable at q, as required. Now, if the indicator returns true at p, m′ 7 → m tells us that a process delivers m′ before m and this must happen before g ∩ h fails. # 6.2 Improving parallelism As motivated in the Introduction, genuine solutions to atomic multicast are appealing from a performance perspective. Indeed, if messages are addressed to disjoint destination groups in a run, they are processed in parallel by such groups. However, when contention occurs, a message may wait for a chain of messages to be delivered first. This chain can span outside
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
of the destination group, creating a delay that harms performance and reduces parallelism [ 17 , 1]. In this section, we explore a stronger form of genuineness, where groups are able to deliver messages independently. We prove that, similarly to the strict variation, this requirement demands more synchrony than μ from the underlying system. # 6.2.1 Definition As standard, a run R is fair for some correct process p when p executes an unbounded amount of steps in R. By extension, R is fair for P ⊆ Correct (R), or for short P -fair, when it is fair for every p in P . If P is exactly the set of correct processes, we simply say that R is fair. (Group Parallelism) Consider a message m and a run R. Note P = Correct (R) ∩ dst (m).If m is delivered by a process, or atomic multicast by a correct process in R, and R is P -fair, then every process in P delivers m in R.Group parallelism bears similarity with x-obstruction freedom [ 38 ], in the sense that the system must progress when a small enough group of processes is isolated. A protocol is said strongly genuine when it satisfy both the minimality and the group parallelism properties. # 6.2.2 About the weakest failure detector Below, we establish that (∧g,h ∈G Ωg∩h) is necessary. It follows that the weakest failure detector for this variation is at least μ ∧ (∧g,h ∈G Ωg∩h). Emulating ∧g,h ∈G Ωg∩h. Consider some algorithm A that solves strongly genuine atomic multicast with failure detector D. Using both A and D, each process may emulate Ωg∩h, for some intersecting groups g, h ∈ G . The emulation follows the general schema of CHT [ 8]. We sketch the key steps below. The full proof
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
appears in . Each process constructs a directed acyclic graph G by sampling the failure detector D and exchanging these samples with other processes. A path π in G induces multiple runs of A that each process locally simulates. A run starts from some initial configuration. In our context, the configurations I = {I1, . . . , I n≥2} of interest satisfy (i) the processes outside P. Sutra 35:15 g ∩ h do not atomic multicast any message, and (ii) the processes in g ∩ h multicast a single message to either g or h. For some configuration Ii ∈ I, the schedules of the simulated runs starting from Ii are stored in a simulation tree Υi. There exists an edge (S, S ′) when starting from configuration S(Ii), one may apply a step s = ( p, m, d ) for some process p, message m transiting in S(Ii) and sample d of D such that S′ = S · s.Every time new samples are received, the forest of the simulation trees (Υ i)i is updated. At each such iteration, the schedules in Υi are tagged using the following valency function: S is tagged with g (respectively, h) if for some successor S′ of S in Υi a process in g ∩ h delivers first a message addressed to g (resp. to h) in configuration S′(Ii). A tagged schedule is univalent when it has a single tag, and bivalent otherwise. As the run progresses, each root of a simulation tree has eventually a stable set of tags. If the root of Υi is g-valent, the root of Υj is h-valent and they are adjacent, i.e., all the processes but some p ∈ g ∩ h are in the same state in Ii and Ij , then p must
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
be correct. Otherwise, there exists a bivalent root of some tree Υi such that for g (respectively, h) a correct process multicasts a message to g (resp., h) in Ii. In this case, similarly to [ 8], there exists a decision gadget in the simulation tree Υi. This gadget is a sub-tree of the form (S, S ′, S ′′ ), with S bivalent, and S′ g-valent and S′′ h-valent (or vice-versa). Using the group parallelism property of A, we may then show that necessarily the deciding process in the gadget, that is the process taking a step toward either S′ or S′′ is correct and belongs to the intersection g ∩ h. Solution when F = ∅. In this case, Algorithm 1 just works. To attain strong genuineness, each log object LOG g∩h is implemented with Σg∩h ∧ Ωg∩h through standard universal construction mechanisms. When F = ∅, μ ∧ (∧g,h ∈G Ωg∩h) is thus the weakest failure detector. The case F̸ = ∅ is discussed in the next section. # 7 Discussion Several definitions for atomic multicast appear in literature (see, e.g., [ 12 , 26 ] for a survey). Some papers consider a variation of atomic multicast in which the ordering property is replaced with: ( Pairwise Ordering ) If p delivers m then m′, every process q that delivers m′ has delivered m before. Under this definition, cycles in the delivery relation ( 7 →) across more than two groups are not taken into account. This is computably equivalent to F = ∅.Hence the weakest failure detector for this variation is (∧g,h ∈G Σg∩h) ∧ (∧g∈G Ωg ).In [ 25 ], the authors show that failure detectors of the class U2 are too weak to solve the pairwise ordering variation. These detectors can be wrong about
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
(at least) two processes. In detail, the class Uk are all the failure detectors D that are k-unreliable, that is they cannot distinguish any pair of failure patterns F and F ′, as long as the faulty processes in F and F ′ are members of a subset W of size k (the “wrong” subset). The result in [ 25 ] is a corner case of the necessity of Σg∩h when g ∩ h = {p, q } and both processes are failure-prone in E. Indeed, Σ{p,q } /∈ U 2. To see this, observe that if q is faulty and p correct, then {p} is eventually the output of Σ{p,q } at p. A symmetrical argument holds for process q in runs where q is correct and p faulty. In the class U2, such values can be output in runs where both processes are correct, contradicting the intersection property of Σ{p,q }.Most atomic multicast protocols [ 30 , 17 , 20 , 10 , 31 , 29 , 13 , 33 ] sidestep the impossibility result in by considering that destination groups are decomposable into a set of disjoint groups, each of these behaving as a logically correct entity. This means that there exists a partitioning P(G) ⊆ 2P satisfying that (i) for every destination group g ∈ G , there exists D I S C 2 0 2 2 35:16 The Weakest Failure Detector for Genuine Atomic Multicast (gi)i ⊆ P(G) with g = ∪igi, (ii) each g ∈ P(G) is correct, and (iii) for any two g, h in P(G), g ∩ h is empty. Since ∧g∈P(G) (Σ g ∧ Ωg ) ⪰ μ, we observe that solving the problem over P(G) is always as difficult as over G. It can also be more demanding in
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
certain cases, e.g., if two groups intersect on a single process p, then p must be reliable. In Figure 1, this happens with process p2. In contrast, to these prior solutions, Algorithm 1 tolerates any number of failures. This is also the case of which relies on a perfect failure detector. Regarding strongly genuine atomic multicast, §6.2 establishes that μ ∧ (∧g,h ∈G Ωg∩h) is the weakest when F = ∅. The case F̸ = ∅ is a bit more intricate. First of all, we may observe that in this case the problem is failure-free solvable: given a spanning tree T of the intersection graph of G, we can deliver the messages according to the order 4Strictly speaking, a spanning tree is required per connected component of the intersection graph. P. Sutra 35:17 6 François Bonnet and Michel Raynal. Looking for the weakest failure detector for k-set agreement in message-passing systems: Is πk the end of the road? In Stabilization, Safety, and Security of Distributed Systems, 11th International Symposium, SSS 2009, Lyon, France, November 3-6, 2009. Proceedings , pages 149–164, 2009. doi:10.1007/978-3-642-05118-0_11 . 7 Tushar Deepak Chandra, Robert Griesemer, and Joshua Redstone. Paxos made live: an engineering perspective. In Indranil Gupta and Roger Wattenhofer, editors, Proceedings of the Twenty-Sixth Annual ACM Symposium on Principles of Distributed Computing, PODC 2007, Portland, Oregon, USA, August 12-15, 2007 , pages 398–407. ACM, 2007. doi:10.1145/ 1281100.1281103 . 8 Tushar Deepak Chandra, Vassos Hadzilacos, and Sam Toueg. The weakest failure detector for solving consensus. J. ACM , 43(4):685–722, July 1996. doi:10.1145/234533.234549 . 9 Tushar Deepak Chandra and Sam Toueg. Unreliable failure detectors for reliable distributed systems. J. ACM , 43(2):225–267, 1996. doi:10.1145/226643.226647 . 10 Paulo R. Coelho, Nicolas Schiper, and Fernando Pedone. Fast atomic multicast. In 47th Annual IEEE/IFIP International Conference on Dependable Systems
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
and Networks, DSN 2017, Denver, CO, USA, June 26-29, 2017 , pages 37–48. IEEE Computer Society, 2017. doi:10.1109/DSN.2017.15 . 11 James A. Cowling and Barbara Liskov. Granola: Low-overhead distributed transaction coordination. In Gernot Heiser and Wilson C. Hsieh, editors, 2012 USENIX Annual Technical Conference, Boston, MA, USA, June 13-15, 2012 , pages 223–235. USENIX As-sociation, 2012. URL: presentation/cowling . 12 Xavier Défago, André Schiper, and Péter Urbán. Total order broadcast and multicast algorithms: Taxonomy and survey. ACM Comput. Surv. , 36(4):372–421, December 2004. doi:10.1145/1041680.1041682 . 13 Carole Delporte-Gallet and Hugues Fauconnier. Fault-tolerant genuine atomic multicast to multiple groups. In Franck Butelle, editor, Procedings of the 4th International Conference on Principles of Distributed Systems, OPODIS 2000, Paris, France, December 20-22, 2000 ,Studia Informatica Universalis, pages 107–122. Suger, Saint-Denis, rue Catulienne, France, 2000. 14 Carole Delporte-Gallet, Hugues Fauconnier, and Rachid Guerraoui. A realistic look at failure detectors. In 2002 International Conference on Dependable Systems and Networks (DSN 2002), 23-26 June 2002, Bethesda, MD, USA, Proceedings , pages 345–353. IEEE Computer Society, 2002. doi:10.1109/DSN.2002.1028919 . 15 Carole Delporte-Gallet, Hugues Fauconnier, Rachid Guerraoui, Vassos Hadzilacos, Petr Kouznetsov, and Sam Toueg. The weakest failure detectors to solve certain fundamen-tal problems in distributed computing. In Proceedings of the Twenty-Third Annual ACM Symposium on Principles of Distributed Computing, PODC 2004, St. John’s, Newfoundland, Canada, July 25-28, 2004 , pages 338–346, 2004. doi:10.1145/1011767.1011818 . 16 Swan Dubois, Rachid Guerraoui, Petr Kuznetsov, Franck Petit, and Pierre Sens. The weakest failure detector for eventual consistency. In Proceedings of the 2015 ACM Symposium on Principles of Distributed Computing , PODC ’15, pages 375–384, New York, NY, USA, 2015. Association for Computing Machinery. doi:10.1145/2767386.2767404 . 17 Vitor Enes, Carlos Baquero, Alexey Gotsman, and Pierre Sutra. Efficient replication via timestamp stability. In Antonio Barbalace, Pramod Bhatotia, Lorenzo Alvisi, and Cristian Cadar, editors,
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
EuroSys ’21: Sixteenth European Conference on Computer Systems, Online Event, United Kingdom, April 26-28, 2021 , pages 178–193. ACM, 2021. doi:10.1145/3447786. 3456236 . 18 Felix C. Freiling, Rachid Guerraoui, and Petr Kuznetsov. The failure detector abstraction. ACM Comput. Surv. , 43(2), February 2011. doi:10.1145/1883612.1883616 . 19 Eli Gafni. Round-by-round fault detectors (extended abstract): Unifying synchrony and asynchrony. In Proceedings of the Seventeenth Annual ACM Symposium on Principles of Distributed Computing , PODC ’98, pages 143–152, New York, NY, USA, 1998. ACM. doi: 10.1145/277697.277724 . D I S C 2 0 2 2 35:18 The Weakest Failure Detector for Genuine Atomic Multicast 20 Alexey Gotsman, Anatole Lefort, and Gregory V. Chockler. White-box atomic multicast. In 49th Annual IEEE/IFIP International Conference on Dependable Systems and Networks, DSN 2019, Portland, OR, USA, June 24-27, 2019 , pages 176–187. IEEE, 2019. doi:10.1109/DSN. 2019.00030 . 21 R. Guerraoui and A. Schiper. Total order multicast to multiple groups. In Proceedings of 17th International Conference on Distributed Computing Systems , pages 578–585, 1997. doi:10.1109/ICDCS.1997.603426 . 22 Rachid Guerraoui, Vassos Hadzilacos, Petr Kuznetsov, and Sam Toueg. The weakest failure detectors to solve quittable consensus and nonblocking atomic commit. SIAM J. Comput. ,41(6):1343–1379, 2012. doi:10.1137/070698877 . 23 Rachid Guerraoui, Maurice Herlihy, Petr Kouznetsov, Nancy Lynch, and Calvin Newport. On the weakest failure detector ever. In Proceedings of the Twenty-sixth Annual ACM Symposium on Principles of Distributed Computing , PODC ’07, pages 235–243, New York, NY, USA, 2007. ACM. doi:10.1145/1281100.1281135 . 24 Rachid Guerraoui and Michel Raynal. The alpha of indulgent consensus. Comput. J. , 50(1):53– 67, 2007. doi:10.1093/comjnl/bxl046 . 25 Rachid Guerraoui and André Schiper. Genuine atomic multicast in asynchronous distributed systems. Theor. Comput. Sci. , 254(1-2):297–316, 2001. doi:10.1016/S0304-3975(99)00161-9 . 26 Vassos Hadzilacos and Sam Toueg. A modular approach to fault-tolerant broadcasts and related problems. Technical report, Cornell University,
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
1994. 27 Maurice Herlihy. Wait-free synchronization. ACM Transactions on Programming Languages and Systems , 11(1):124–149, January 1991. doi:10.1145/114005.102808 . 28 Maurice Herlihy and Jeannette Wing. Linearizability: a correcteness condition for concurrent objects. ACM Transactions on Programming Languages and Systems , 12(3):463–492, July 1990. doi:10.1145/78969.78972 . 29 Udo Fritzke Jr., Philippe Ingels, Achour Mostéfaoui, and Michel Raynal. Consensus-based fault-tolerant total order multicast. IEEE Trans. Parallel Distributed Syst. , 12(2):147–156, 2001. doi:10.1109/71.910870 . 30 Long Hoang Le, Mojtaba Eslahi-Kelorazi, Paulo R. Coelho, and Fernando Pedone. Ramcast: Rdma-based atomic multicast. In Kaiwen Zhang, Abdelouahed Gherbi, Nalini Venkata-subramanian, and Luís Veiga, editors, Middleware ’21: 22nd International Middleware Conference, Québec City, Canada, December 6 - 10, 2021 , pages 172–184. ACM, 2021. doi:10.1145/3464298.3493393 . 31 Parisa Jalili Marandi, Marco Primi, and Fernando Pedone. Multi-ring paxos. In Robert S. Swarz, Philip Koopman, and Michel Cukier, editors, IEEE/IFIP International Conference on Dependable Systems and Networks, DSN 2012, Boston, MA, USA, June 25-28, 2012 , pages 1–12. IEEE Computer Society, 2012. doi:10.1109/DSN.2012.6263916 . 32 Shuai Mu, Lamont Nelson, Wyatt Lloyd, and Jinyang Li. Consolidating concurrency control and consensus for commits under conflicts. In Kimberly Keeton and Timothy Roscoe, editors, 12th USENIX Symposium on Operating Systems Design and Implementation, OSDI 2016, Savannah, GA, USA, November 2-4, 2016 , pages 517–532. USENIX Association, 2016. URL: . 33 Luís E. T. Rodrigues, Rachid Guerraoui, and André Schiper. Scalable atomic multicast. In Proceedings of the International Conference On Computer Communications and Networks (IC-CCN 1998), October 12-15, 1998, Lafayette, Louisiana, USA , pages 840–847. IEEE Computer Society, 1998. doi:10.1109/ICCCN.1998.998851 . 34 Nicolas Schiper and Fernando Pedone. Solving atomic multicast when groups crash. In Theodore P. Baker, Alain Bui, and Sébastien Tixeuil, editors, Principles of Distributed Systems, 12th International Conference, OPODIS 2008, Luxor, Egypt, December 15-18, 2008. Proceedings , volume 5401 of Lecture
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
Notes in Computer Science , pages 481–495. Springer, 2008. doi:10.1007/978-3-540-92221-6_30 .P. Sutra 35:19 35 Nicolas Schiper, Pierre Sutra, and Fernando Pedone. Genuine versus non-genuine atomic multicast protocols for wide area networks: An empirical study. In 28th IEEE Symposium on Reliable Distributed Systems (SRDS 2009), Niagara Falls, New York, USA, September 27-30, 2009 , pages 166–175. IEEE Computer Society, 2009. doi:10.1109/SRDS.2009.12 . 36 Nicolas Schiper, Pierre Sutra, and Fernando Pedone. P-store: Genuine partial replication in wide area networks. In 29th IEEE Symposium on Reliable Distributed Systems (SRDS 2010), New Delhi, Punjab, India, October 31 - November 3, 2010 , pages 214–224. IEEE Computer Society, 2010. doi:10.1109/SRDS.2010.32 . 37 Pierre Sutra. The weakest failure detector for genuine atomic multicast (extended version), 2022. doi:10.48550/ARXIV.2208.07650 . 38 Gadi Taubenfeld. Contention-sensitive data structures and algorithms. Theoretical Computer Science , 677:41–55, 2017. doi:10.1016/j.tcs.2017.03.017 . D I S C 2 0 2 2
|
{
"page_id": null,
"source": 7321,
"title": "from dpo"
}
|
Title: Tame the Wild with Byzantine Linearizability: Reliable Broadcast, Snapshots, and Asset Transfer URL Source: Markdown Content: # Tame the Wild with Byzantine Linearizability: Reliable Broadcast, Snapshots, and Asset Transfer # Shir Cohen # Technion, Haifa, Israel # Idit Keidar # Technion, Haifa, Israel Abstract We formalize Byzantine linearizability, a correctness condition that specifies whether a concurrent object with a sequential specification is resilient against Byzantine failures. Using this definition, we systematically study Byzantine-tolerant emulations of various objects from registers. We focus on three useful objects– reliable broadcast, atomic snapshot, and asset transfer. We prove that there exist n-process f -resilient Byzantine linearizable implementations of such objects from registers if and only if f 2 . 2012 ACM Subject Classification Theory of computation → Concurrent algorithms Keywords and phrases Byzantine linearizability, concurrent algorithms, snapshot, asset transfer Digital Object Identifier 10.4230/LIPIcs.DISC.2021.18 Related Version Full Version : # 1 Introduction Over the last decade, cryptocurrencies have taken the world by storm. The idea of a decen-tralized bank, independent of personal motives has gained momentum, and cryptocurrencies like Bitcoin [ 23 ], Ethereum [ 25 ], and Diem [ 8] now play a big part in the world’s economy. At the core of most of these currencies lies the asset transfer problem. In this problem, there are multiple accounts, operated by processes that wish to transfer assets between accounts. This environment raises the need to tolerate the malicious behavior of processes that wish to sabotage the system. In this work, we consider the shared memory model that was somewhat neglected in the Byzantine discussion. We believe that shared memory abstractions, implemented in distributed settings, allow for an intuitive formulation of the services offered by blockchains and similar decentralized tools. It is well-known that it is possible to
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
implement reliable read-write shared memory registers via message passing even if a fraction of the servers are Byzantine [ 1, 21 , 24 , 19 ]. As a result, as long as the client processes using the service are not malicious, any fault-tolerant object that can be constructed using registers can also be implemented in the presence of Byzantine servers. However, it is not clear what can be done with such objects when they are used by Byzantine client processes. In this work, we study this question. In Section 4 we define Byzantine linearizability , a correctness condition applicable to any shared memory object with a sequential specification. Byzantine linearizability addresses the usage of reliable shared memory abstractions by potentially Byzantine client processes. We then systematically study the feasibility of implementing various Byzantine linearizable shared memory objects from registers. > ©Shir Cohen and Idit Keidar; licensed under Creative Commons License CC-BY 4.0 35th International Symposium on Distributed Computing (DISC 2021). Editor: Seth Gilbert; Article No. 18; pp. 18:1–18:18 Leibniz International Proceedings in Informatics > Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl Publishing, Germany 18:2 Tame the Wild with Byzantine Linearizability We observe that existing Byzantine fault-tolerant shared memory constructions [ 20 , 22 , 1]in fact implement Byzantine linearizable registers. Such registers are the starting point of our study. When trying to implement more complex objects (e.g., snapshots and asset transfer) using registers, constructions that work in the crash-failure model no longer work when Byzantine processes are involved, and new algorithms – or impossibility results – are needed. As our first result, we prove in Section 5 that an asset transfer object used by Byzantine client processes does not have a wait-free implementation, even when its API is reduced to support only transfer operations (without reading processes’ balances). Furthermore, it
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
cannot be implemented without a majority of correct processes constantly taking steps. Asset transfer has wait-free implementations from both reliable broadcast [ 7] and snapshots 17 and thus the same lower bound applies to reliable broadcast and snapshots as well. In Section 6, we present a Byzantine linearizable reliable broadcast algorithm with resilience f 2 , proving that, for this object, the resilience bound is tight. To do so, we define a sequential specification of a reliable broadcast object. Briefly, the object exposes broadcast and deliver operations and we require that deliver return messages previously broadcast. We show that a Byzantine linearizable implementation of such an object satisfies the classical (message-passing) definition [ 10 ]. Finally, in Section 7 we present a Byzantine linearizable snapshot with the same resilience. In contrast, previous constructions of Byzantine lattice agreement, which can be directly constructed from a snapshot [ 6], required 3f + 1 processes to tolerate f failures. All in all, we establish a tight bound on the resilience of emulations of three useful shared memory objects from registers. On the one hand, we show that it is impossible to obtain wait-free solutions as in the non-Byzantine model, and on the other hand, unlike previous snapshot and lattice agreement algorithms, our solutions do not require n > 3f . Taken jointly, our results yield the following theorem: ▶ Theorem 1. In the Byzantine shared memory model, there exist n-process f -resilient Byzantine linearizable implementations of reliable broadcast, snapshot, and asset transfer objects from registers if and only if f 2 . Although the construction of reliable registers in message passing systems requires n > 3f servers, our improved resilience applies to client processes, which are normally less reliable
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
than servers, particularly in the so-called permissioned model where servers are trusted and clients are ephemeral. In summary, we make the following contributions: Formalizing Byzantine linearizability for any object with a sequential specification. Proving that some of the most useful building blocks in distributed computing, such as atomic snapshot and reliable broadcast, do not have f -resilient implementations from SWMR registers when f ≥ n > 2 processes are Byzantine. Presenting Byzantine linearizable implementations of a reliable broadcast object and a snapshot object with the optimal resilience. # 2 Related Work In [ 4] Aguilera et al. present a non-equivocating broadcast algorithm in shared memory. This broadcast primitive is weaker than reliable broadcast – it does not guarantee that all correct processes deliver the same messages, but rather that they do not deliver conflicting messages. A newer version of their work [ 5 ], developed concurrently and independently of S. Cohen and I. Keidar 18:3 our work 1, also implements reliable broadcast with n ≥ 2f + 1 , which is very similar to our implementation. While the focus of their work is in the context of RDMA in the M&M (message–and–memory) model, our work focuses on the classical shared memory model, which can be emulated in classical message passing systems. While the algorithms are similar, we formulate reliable broadcast as a shared memory object, with designated API method signatures, which allows us to reason about the operation interval as needed for proving (Byzantine) linearizability and for using this object in constructions of other shared memory objects. Given a reliable broadcast object, there are known implementations of lattice agree-ment [ 16 , 26 ], which resembles a snapshot object. However, these constructions require n = 3 f + 1 processes. In our work, we present both Byzantine linearizable reliable broadcast
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
and Byzantine snapshot, (from which Byzantine lattice agreement can be constructed [ 6 ]), with resilience n = 2 f + 1 .The asset transfer object we discuss in this paper was introduced by Guerraoui et al. [ 17 , 15 ]. Their work provides a formalization of the cryptocurrency definition [ 23 ]. The highlight of their work is the observation that the asset transfer problem can be solved without consensus. It is enough to maintain a partial order of transactions in the systems, and in particular, every process can record its own transactions. They present a wait-free linearizable implementation of asset transfer in crash-failure shared memory, taking advantage of an atomic snapshot object. We show that we can use their solution, together with our Byzantine snapshot, to solve Byzantine linearizable asset transfer with n = 2 f + 1 .In addition, Guerraoui et al. present a Byzantine-tolerant solution in the message passing model. This algorithm utilizes reliable broadcast, where dependencies of transactions are explicitly broadcast along with the transactions. This solution does not translate to a Byzantine linearizable one, but rather to a sequentially consistent asset transfer object. In particular, reads can return old (superseded) values, and transfers may fail due to outdated balance reads. Finally, recent work by Auvolat et al. [ 7] continues this line of work. They show that a FIFO order property between each pair of processes is sufficient in order to solve the asset transfer problem. This is because transfer operations can be executed once a process’s balance becomes sufficient to perform a transaction and there is no need to wait for all causally preceding transactions. However, as a result, their algorithm is not sequentially consistent, or even causally consistent for that matter. For example, assume process i maintains an invariant that its
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
balance is always at least 10, and performs a transfer with amount 5 after another process deposits 5 into its account, increasing its balance to 15. Using the protocol in [ 7], another process might observe i’s balance as 5 if it sees i’s outgoing transfer before the causally preceding deposit. Because our solution is Byzantine linearizable, such anomalies are prevented. # 3 Model and Preliminaries We study a distributed system in the shared memory model. Our system consists of a well-known static set Π = {1, . . . , n } of asynchronous client processes. These processes have access to some shared memory objects. In the shared memory model, all communication between processes is done through the API exposed by the objects in the system: processes invoke operations that in turn, return some response to the process. In this work, we assume > 1Their work was in fact published shortly after the initial publication of our results . D I S C 2 0 2 1 18:4 Tame the Wild with Byzantine Linearizability a reliable shared memory. (Previous works have presented constructions of such reliable shared memory in the message passing model [ 1, 21 , 24 , 3, 19 ]). We further assume an adversary that may adaptively corrupt up to f processes in the course of a run. When the adversary corrupts a process, it is defined as Byzantine and may deviate arbitrarily from the protocol. As long as a process is not corrupted by the adversary, it is correct , follows the protocol, and takes infinitely many steps. In particular, it continues to invoke the object’s API infinitely often. Later in the paper, we show that the latter assumption is necessary. We enrich the model with a public key infrastructure (PKI). That is, every
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
process is equipped with a public-private key pair used to sign data and verify signatures of other processes. We denote a value v signed by process i as ⟨v⟩i. Executions and Histories. We discuss algorithms emulating some object O from lower level objects (e.g., registers). An algorithm is organized as methods of O. A method execution is a sequence of steps , beginning with the method’s invocation (invoke step), proceeding through steps that access lower level objects (e.g., register read/write), and ending with a return step. The invocation and response delineate the method’s execution interval. In an execution σ of a Byzantine shared memory algorithm, each correct process invokes methods sequentially, where steps of different processes are interleaved. Byzantine processes take arbitrary steps regardless of the protocol. The history H of an execution σ is the sequence of high-level invocation and response events of the emulated object O in σ.A sub-history of a history H is a sub-sequence of the events of H. A history H is sequential if it begins with an invocation and each invocation, except possibly the last, is immediately followed by a matching response. Operation op is pending in a history H if op is invoked in H but does not have a matching response event. A history defines a partial order on operations: operation op 1 precedes op 2 in history H,denoted op 1 ≺H op 2, if the response event of op 1 precedes the invocation event of op 2 in H.Two operations are concurrent if neither precedes the other. Linearizability. A popular correctness condition for concurrent objects in the crash-fault model is linearizability [ 18 ], which is defined with respect to an object’s sequential specification. A linearization of a concurrent history H of object o is a sequential history H′ such that
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
(1) after removing some pending operations from H and completing others by adding matching responses, it contains the same invocations and responses as H′, (2) H′ preserves the partial order ≺H , and (3) H′ satisfies o’s sequential specification. f-resilient. An algorithm is f-resilient if as long as at most f processes fail, every correct process eventually returns from each operation it invokes. A wait-free algorithm is a special case where f = n − 1. Single Writer Multiple Readers Register. The basic building block in shared memory is a single writer multiple readers (SWMR) register that exposes read and write operations. Such registers are used to construct more complicated objects. The sequential specification of a SWMR register states that every read operation from register R returns the value last written to R. Note that if the writer is Byzantine, it can cause a correct reader to read arbitrary values. S. Cohen and I. Keidar 18:5 Asset Transfer Object. In [ 17 , 15 ], the asset transfer problem is formulated as a sequential object type, called Asset Transfer Object . The asset transfer object maintains a mapping from processes in the system to their balances 2. Initially, the mapping contains the initial balances of all processes. The object exposes a transfer operation, transfer(src,dst,amount) ,which can be invoked by process src (only). It withdraws amount from process src ’s account and deposits it at process dst ’s account provided that src ’s balance was at least amount . It returns a boolean that states whether the transfer was successful (i.e., src had amount to spend). In addition, the object exposes a read(i) operation that returns the current balance of i. # 4 Byzantine Linearizability In this section we define Byzantine linearizability. Intuitively, we would like to tame the Byzantine behavior
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
in a way that provides consistency to correct processes. We linearize the correct processes’ operations and offer a degree of freedom to embed additional operations by Byzantine processes. We denote by H|correct the projection of a history H to all correct processes. We say that a history H is Byzantine linearizable if H|correct can be augmented with operations of Byzantine processes such that the completed history is linearizable. That is, there is another history, with the same operations by correct processes as in H, and additional operations by another at most f processes. In particular, if there are no Byzantine failures then Byzantine linearizability is simply linearizability. Formally: ▶ Definition 2 (Byzantine Linearizability) . A history H is Byzantine linearizable if there exists a history H′ so that H′|correct = H|correct and H′ is linearizable. Similarly to linearizability, we say that an object is Byzantine linearizable if all of its executions are Byzantine Linearizable. Next, we characterize objects for which Byzantine linearizability is meaningful. The most fundamental component in shared memory is read-write registers. Not surprisingly, such registers, whether they are single-writer or multi-writers ones are de facto Byzantine linearizable without any changes. This is because before every read from a Byzantine register, invoked by a correct process, one can add a corresponding Byzantine write. In practice, multiple writers multiple readers (MWMR) registers are useless in a Byzantine environment as an adversary that controls the scheduler can prevent any communication between correct processes. SWMR registers, however, are still useful for constructing more meaningful objects. Nevertheless, the constructions used in the crash-failure model for linearizable objects do not preserve this property. For instance, if we allow Byzantine processes to run a classic atomic snapshot algorithm [ 2] using Byzantine linearizable SWMR registers, it will not result in a Byzantine linearizable snapshot
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
object. The reason is that the algorithm relies on correct processes being able to perform “double-collect” meaning that at some point a correct process manages to read all registers twice without witnessing any changes. While this is true in the crash-failure model, in the Byzantine model this is not the case as the adversary can change some registers just before any correct read. > 2The definition in [ 17 ] allows processes to own multiple accounts. For simplicity, we assume a single account per-process, as in . D I S C 2 0 2 1 18:6 Tame the Wild with Byzantine Linearizability Relationship to Other Correctness Conditions Byzantine linearizability provides a simple and intuitive way to capture Byzantine behavior in the shared memory model. We now examine the relationship of Byzantine linearizability with previously suggested correctness conditions involving Byzantine processes. PBFT [ 12 , 11 ] presented a formalization of linearizability in the presence of Byzantine-faulty clients in message passing systems. Their notion of linearizability is formulated in the form of I/O automata. Their specification is in the same spirit as ours, but our formulation is closer to the original notion of linearizability in shared memory. Some works have defined linearization conditions for specific objects. This includes conditions for SWMR registers [ 22 ], a distributed ledger [ 13 ], and asset transfer [ 7]. Our condition coincides with these definitions for the specific objects and thus generalizes all of them. Liskov and Rodrigues [ 20 ] presented a correctness condition that has additional restrictions. Their correctness notion relies on the idea that Byzantine processes are eventually detected and removed from the system and focuses on converging to correct system behavior after their departure. While this model is a good fit when the threat model is software bugs or malicious
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
intrusions, it is less appropriate for settings like cryptocurrencies, where Byzantine behavior cannot be expected to eventually stop. # 5 Lower Bound on Resilience In shared memory, one typically aims for wait-free objects, which tolerate any number of process failures. Indeed, many useful objects have wait-free implementations from SWMR registers in the non-Byzantine case. This includes reliable broadcast, snapshots, and as recently shown, also asset transfer. We now show that in the Byzantine case, wait-free implementations of these objects are impossible. Moreover, a majority of correct processes is required. ▶ Theorem 3. In the Byzantine shared memory model, for any f > 2, there does not exist a Byzantine linearizable implementation of asset transfer that supports only transfer operations in a system with n ≤ 2f processes, f of which can be Byzantine, using only SWMR registers. Note that to prove this impossibility, it does not suffice to introduce bogus actions by Byzantine processes, because the notion of Byzantine linearizability allows us to ignore these actions. Rather, to derive the contradiction, we create runs where the bogus behavior of the Byzantine processes leads to incorrect behavior of the correct processes. Proof. Assume by contradiction that there is such an algorithm. Let us look at a system with n = 2 f correct processes. Partition Π as follows: Π = A ∪ B ∪ { p1, p 2}, where |A| = f − 1, |B| = f − 1, A ∩ B = ∅, and p1, p 2 /∈ A ∪ B. By assumption, |A| > 1. Let z be a process in A. Also, by assumption |B| ≥ 2. Let q1, q 2 be processes in B. The initial balance of all processes but z is 0, and the initial balance of z is 1. We construct four executions as
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
shown in Figure 1. Let σ1 be an execution where, only processes in A ∪ { p1} take steps. First, z performs transfer( z, p 1,1) . Since up to f processes may be faulty, the operation completes, and by the object’s sequential specification, it is successful (returns true). Then, p1 performs transfer( p1, q 1,1) . By f -resilience and linearizability, this operation also completes successfully. Note that in σ1 no process is actually faulty, but because of f -resilience, progress is achieved when f processes are silent. Similarly, let σ2 be an execution where the processes in A ∪ { p2} are correct, and z performs transfer( z, p 2,1) , followed by p2 performing transfer( p2, q 2,1) .S. Cohen and I. Keidar 18:7 > Figure 1 An asset transfer object does not have an f-resilient implementation for n≤2f. We now construct σ3, where all processes in A ∪ { p1} are Byzantine. We first run σ1. Call the time when it ends t1. At this point, all processes in A ∪ { p1} restore their registers to their initial states. Note that no other processes took steps during σ1, hence the entire shared memory is now in its initial state. Then, we execute σ2. Because we have reset the memory to its initial state, the operations execute the same way. When σ2 completes, processes in A\{ z} ∪ { p1} restore their registers to their state at time t1. At this point, the state of z and p2 is the same as it was at the end of σ2, the state of processes in A \ { z} ∪ { p1} is the same as it was at the end of σ1, and processes in B are all in their initial states. We construct σ4 where
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
all processes in A ∪ { p2} are Byzantine by executing σ2, having all processes in A ∪ { p2} reset their memory, executing σ1, and then having z and p2 restore their registers to their state at the end of σ2. At this point, the state of z and p2 is the same as it was at the end of σ2, the state of processes in A \ { z} ∪ { p1} is the same as it was at the end of σ1, and processes in B are all in their initial states. We observe that for processes in B, the configurations at the end of σ3 and σ4 are indistinguishable as they did not take any steps and the global memory is the same. By f -resilience, in both cases q1 and q2, together with processes in B and one of {p1, p 2} should be able to make progress at the end of each of these runs. We extend the runs by having q1 and q2 invoke transfers of amount 1 to each other. In both runs processes in B ∪ { p1, p 2} help them make progress. In σ3, p1 behaves as if it is a correct process and its local state is the same as it is at the end of σ1, and in σ4 p2 behaves as if it is a correct process and its local state is the same as it is at the end of σ2. Thus, σ3 and σ4 are indistinguishable to all correct processes, and as a result q1 and q2 act the same in both runs. However, from safety exactly one of their transfers should succeed. In σ3, p2 is correct and transfer( p2, q 2,1) succeeds, allowing q2 to transfer 1 and disallowing the transfer from
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
q1, whereas σ4 the opposite is true. This is a contradiction. ◀ Guerraoui et al. [ 17 ] use an atomic snapshot to implement an asset transfer object in the crash-fault shared memory model. In addition, they handle Byzantine processes in the message passing model by taking advantage of reliable broadcast. In Appendix A we show that their atomic snapshot-based asset transfer can be easily adapted to the Byzantine settings by using a Byzantine linearizable snapshot, resulting in a Byzantine linearizable asset transfer. Their reliable broadcast-based algorithm, on the other hand, is not linearizable and therefore not Byzantine linearizable even when using Byzantine linearizable reliable broadcast. Nonetheless, Auvolat et al. [ 7] have used reliable broadcast to construct an asset transfer object where transfer operations are linearizable (although reads are not). D I S C 2 0 2 1 18:8 Tame the Wild with Byzantine Linearizability We note that our lower bound holds for an asset transfer object without read operations. In Algorithm 4 in Appendix A we construct an asset transfer object given a Byzantine linearizable snapshot (proofs appear in the full version [ 14 ]). The above discussion and the construction in Algorithm 4 lead us to the following corollary: ▶ Corollary 4. In the Byzantine shared memory model, for any f > 2, there does not exist an f -resilient Byzantine linearizable implementation of an atomic snapshot or reliable broadcast in a system with f ≥ n > 2 Byzantine processes using only SWMR registers. Furthermore, we prove in the following lemma that in order to provide f -resilience it is required that at least a majority of correct processes take steps infinitely often, justifying our model definition. ▶ Lemma 5. In the Byzantine shared memory model, for any f > 2, there does not exist an
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
f -resilient Byzantine linearizable implementation of asset transfer in a system with n ≥ 2f + 1 processes, f of which can be Byzantine, using only SWMR registers if less than f + 1 correct processes take steps infinitely often. Proof. Assume by way of contradiction that there exists an f -resilient Byzantine linearizable implementation of asset transfer in a system with n ≥ 2f + 1 processes where there are at most f correct processes that take steps infinitely often. Denote these f correct processes by the set A. Thus, there is a point t in any execution such that from time t, only processes in A and Byzantine processes take any steps. Starting t, the implementation is equivalent to one in a system with n = 2 f , f of them may be Byzantine. This is a contradiction to Theorem 3. ◀ # 6 Byzantine Linearizable Reliable Broadcast With the acknowledgment that not all is possible, we seek to find Byzantine linearizable objects that are useful even without a wait-free implementation. One of the practical objects is a reliable broadcast object. We already proved in the previous section that it does not have an f -resilient Byzantine linearizable implementation, for any f ≥ max {3, n > 2 }. In this section we provide an implementation that tolerates f 2 faults. # 6.1 Reliable Broadcast Object The reliable broadcast primitive exposes two operations broadcast(ts,m) returning void and deliver(j,ts) returning m. When deliver j (i, ts ) returns m we say that process j delivers m from process i in timestamp ts . The broadcast operation allows processes to spread a message m in the system, along with some timestamp ts . The use of timestamps allows processes to broadcast multiple messages. Its classical definition,
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
given for message passing systems [ 10 ], requires the following properties: Validity: If a correct process i broadcasts (ts, m ) then all correct processes eventually deliver m from process i in timestamp ts .Agreement: If a correct process delivers m from process i in timestamp ts , then all correct processes eventually deliver m from process i in timestamp ts .Integrity: No process delivers two different messages for the same (ts, j ) and if j is correct delivers only messages j previously broadcast. S. Cohen and I. Keidar 18:9 In the shared memory model, the deliver operation for some process j and timestamp ts returns the message with timestamp ts previously broadcast by j, if exists. We define the sequential specification of reliable broadcast as follows: ▶ Definition 6. A reliable broadcast object exposes two operations broadcast(ts,m) returning void and deliver(j,ts) returning m. A call to deliver(j,ts) returns the value m of the first broadcast(ts,m) invoked by process j before the deliver operation. If j did not invoke broadcast before the deliver, then it returns ⊥. Note that as the definition above refers to sequential histories, the first broadcast operation (if such exists) is well-defined. Further, whereas in message passing systems reliable broadcast works in a push fashion, where the receipt of a message triggers action at its destination, in the shared memory model processes need to actively pull information from the registers. A process pulls from another process j using the deliver(j,ts) operation and returns with a value m̸ = ⊥. If all messages are eventually pulled, the reliable broadcast properties are achieved, as proven in the following lemma. ▶ Lemma 7. A Byzantine linearization of a reliable broadcast object satisfies the three properties of reliable broadcast. Proof. If a correct process broadcasts m, and all
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
messages are subsequently pulled then according to Definition 6 all correct processes deliver m, providing validity. For agreement, if a correct process invokes deliver(j,ts) that returns m and all messages are later pulled by all correct processes, it follows that all correct processes also invoke deliver(j,ts) and eventually return m′̸ = ⊥. Since deliver(j,ts) returns the value v of the first broadcast(ts,v) invoked by process j before it is called, and there is only one first broadcast, and we get that m = m′.Lastly, if deliver(j,ts) returns m, by the specification, j previously invoked broadcast(ts,m) . ◀ # 6.2 Reliable Broadcast Algorithm In our implementation (given in Algorithm 1), each process has 4 SWMR registers: send, echo, ready, and deliver, to which we refer as stages of the broadcast. We follow concepts from Bracha’s implementation in the message passing model [ 9 ] but leverage the shared memory to improve its resilience from 3f + 1 to 2f + 1 . The basic idea is that a process that wishes to broadcast value v writes it in its send register (line 4) and returns only when it reaches the deliver stage. I.e., v appears in the deliver register of at least one correct process. Throughout the run, processes infinitely often call a refresh function whose role is to help the progress of the system. When refreshing, processes read all registers and help promote broadcast values through the 4 stages. For a value to be delivered, it has to have been read and signed by f + 1 processes at the ready stage. Because each broadcast message is copied to 4 registers of each process, the space complexity is 4n per message. Whether this complexity can be improved remains as an open question. In the refresh function, executed for all processes,
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
at first a process reads the last value written to a send register (line 16). If the value is a signed pair of a message and a timestamp, refresh then copies it to the process’s echo register in line 18. In the echo register, the value remains as evidence, preventing conflicting values (sent by Byzantine processes) from being delivered. That is, before promoting a value to the ready or deliver stage, a correct process i performs a “double-collect” of the echo registers (in lines 19,21). Namely, after collecting f + 1 signatures on a value in ready registers, meaning that it was previously written in the echo of at least one correct process, i re-reads all echo registers to verify that there does D I S C 2 0 2 1 18:10 Tame the Wild with Byzantine Linearizability not exist a conflicting value (with the same timestamp and sender). Using this method, concurrent deliver operations “see” each other, and delivery of conflicting values broadcast by a Byzantine process is prevented. Before delivering a value, a process writes it to its deliver register with f + 1 signatures (line 22). Once one correct process delivers a value, the following deliver calls can witness the f + 1 signatures and copy this value directly from its deliver register (line 11). > Algorithm 1 Shared Memory Bracha: code for process i. shared SWMR registers: send i, echo i, ready i, deliver i > 1: procedure conflicting-echo (⟨ts, v ⟩j ) > 2: return ∃w̸ = v, k ∈ Π such that ⟨ts, w ⟩j ∈ echo k > 3: procedure broadcast (ts,val) > 4: send i ← ⟨ ts, val ⟩i > 5: repeat > 6: m ← deliver(i,ts) > 7: until m̸ = ⊥ ▷ message is deliverable > 8: procedure deliver
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
(j,ts) > 9: refresh() > 10: if ∃k ∈ Π and v s.t. ⟨⟨ ts, v ⟩j , σ ⟩ ∈ deliver k where σ is a set of f + 1 signatures on ⟨ready, ⟨ts, v ⟩j ⟩ then > 11: deliver i ← deliver i ∪ {⟨⟨ ts, v ⟩j , σ ⟩} > 12: return v > 13: return ⊥ > 14: procedure refresh > 15: for j ∈ [n] do > 16: m ← send j > 17: if ∄ts , val s.t. m = ⟨ts, val ⟩j then continue ▷ m is not a signed pair > 18: echo i ← echo i ∪ { m} > 19: if ¬conflicting-echo (m) then > 20: ready i ← ready i ∪ {⟨ ready, m ⟩i} > 21: if ∃S ⊆ Π s.t. |S| ≥ f + 1 , ∀j ∈ S, ⟨ready, m ⟩j ∈ ready j and ¬conflicting-echo (m) then > 22: deliver i ← deliver i ∪ {⟨ m, σ = {⟨ ready, m ⟩j |j ∈ S}⟩} ▷ σ is the set of f + 1 signatures We make two assumptions on the correct usage of our algorithm. The first is inherently required as shown in Lemma 5: ▶ Assumption 1. All correct processes infinitely often invoke methods of the reliable broadcast API. The second is a straight forward validity assumption: ▶ Assumption 2. Correct processes do not invoke broadcast(ts,val) twice with the same ts .S. Cohen and I. Keidar 18:11 In the full version [ 14 ] we prove the correctness of the reliable broadcast algorithm and conclude the following theorem: ▶ Theorem 8. Algorithm 1 implements an f -resilient Byzantine linearizable reliable broadcast object for any f 2 . # 7 Byzantine Linearizable Snapshot In this section, we
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
utilize a reliable broadcast primitive to construct a Byzantine snapshot object with resilience n > 2f . # 7.1 Snapshot Object A snapshot [ 2 ] is represented as an array of n shared single-writer variables that can be accessed with two operations: update(v) , called by process i, updates the ith entry in the array and snapshot returns an array. The sequential specification of an atomic snapshot is as follows: the ith entry of the array returned by a snapshot invocation contains the value v last updated by an update(v) invoked by process i, or its variable’s initial value if no update was invoked. Following Lemma 5, we again must require that correct processes perform operations infinitely often. For simplicity, we require that they invoke infinitely many snapshot operations; if processes invoke either snapshots or updates, we can have each update perform a snapshot and ignore its result. ▶ Assumption 3. All correct processes invoke snapshot operations infinitely often. # 7.2 Snapshot Algorithm Our pseudo-code is presented in Algorithms 2 and 3. During the algorithm, we compare snapshots using the (partial) coordinate-wise order. That is, let s1 and s2 be two n-arrays. We say that s2 > s 1 if ∀i ∈ [n], s2[i].ts > s 1[i].ts .Recall that all processes invoke snapshot operations infinitely often. In each snapshot instance, correct processes start by collecting values from all registers and broadcasting their collected arrays in “start” messages (message with timestamp 0). Then, they repeatedly send the identities of processes from which they delivered start messages until there exists a round such that the same set of senders is received from f + 1 processes in that round. Once this occurs, it means that the f + 1 processes see the exact same start messages and the snapshot is formed
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
as the supremum of the collects in their start messages. We achieve optimal resilience by waiting for only f + 1 processes to send the same set. Although there is not necessarily a correct process in the intersection of two sets of size f + 1 ,we leverage the fact that reliable broadcast prevents equivocation to ensure that nevertheless, there is a common message in the intersection, so two snapshots obtained in the same round are necessarily identical. Moreover, once one process obtains a snapshot s, any snapshot seen in a later round exceeds s.Each process i collects values from all processes’ registers in a shared variable collect i.When starting a snapshot operation, each process runs update-collect, where it updates its collect array (line 8) and saves it in a local variable c (line 9). When it does so, it updates the ith entry to be the highest-timestamped value it observes in the ith entries of all processes’ collect arrays (lines 16 – 18). Then, it initiates the snapshot-aux procedure with a new D I S C 2 0 2 1 18:12 Tame the Wild with Byzantine Linearizability > Algorithm 2 Byzantine Snapshot: code for process i. shared SWMR registers: ∀j ∈ [n] collected i[j] ∈ {⊥} ∪ { N × V als } with selectors ts and val, initially ⊥∀k ∈ N, savesnap i[k] ∈ {⊥} ∪ { array of n V als × set of messages } with selectors snap and proof, initially ⊥ local variables: ts i ∈ N, initially 0 ∀j ∈ [n], rts i[j] ∈ N, initially 0 r, auxnum ∈ N, initially 0 p ∈ [n], initially 1 ∀j ∈ [n], k ∈ N, seen i[j][k] ,senders i ∈ P (Π) , initially ∅ σ ← ∅ set of messages > 1: procedure update
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
(v) > 2: for j ∈ [n] do ▷ collect current memory state > 3: update-collect( collected j ) > 4: ts i ← ts i + 1 > 5: collected i[i] ← ⟨ ts i, v ⟩i ▷ update local component of collected > 6: procedure snapshot > 7: for j ∈ [n] do ▷ collect current memory state > 8: update-collect( collected j ) > 9: c ← collected i > 10: repeat > 11: auxnum ← auxnum + 1 > 12: snap ← snapshot-aux (auxnum ) > 13: until snap ≥ c ▷ snapshot is newer than the collected state > 14: return snap > 15: procedure update-collect (c) > 16: for k ∈ [n] do > 17: if c[k].ts > collected i[k].ts and c[k] is signed by k then > 18: collected i[k] ← c[k] auxnum tag. Snapshot-aux returns a snapshot, but not necessarily a “fresh” one that reflects all updates that occurred before snapshot was invoked. Therefore, snapshot-aux is repeatedly called until it collects a snapshot s such that s ≥ c, according to the snapshots partial order (lines 10 – 13). By Assumption 3 and since the auxnum variable at each correct process is increased by 1 every time snapshot-aux is called, all correct processes participate in all instances of snapshot-aux. When a correct process invokes a snapshot-aux procedure with auxnum, it first initiates a new reliable broadcast instance at line 28, dedicated to this instance of snapshot-aux. Note that although processes invoke one snapshot-aux at a time, they may engage in multiple reliable broadcast instances simultaneously. That is, they continue to partake in previous reliable broadcast instances after starting a new one. As another preliminary step of snapshot-aux, each correct process once again updates its collect array using the update-collect procedure (lines 30–
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
31) and broadcasts it to all processes at line 33. S. Cohen and I. Keidar 18:13 Algorithm 3 Byzantine Snapshot auxiliary procedures: code for process i. 19: procedure minimum-saved (auxnum) 20: S ← { s|∃ j ∈ [n], s = savesnap j [auxnum ].snap and savesnap j [auxnum ].proof is a valid proof of s} 21: if S = ∅ then 22: return ⊥ 23: res ← infimum (S) ▷ returns the minimum value in each index 24: savesnap i[auxnum ] ← ⟨ res, ⋃ > j∈[n] savesnap j [auxnum ].proof ⟩ 25: update-collect( res ) 26: return res 27: procedure snapshot-aux (auxnum) 28: initiate new reliable broadcast instance 29: σ ← ∅ 30: for j ∈ [n] do ▷ collect current memory state 31: update-collect( collected j ) 32: senders i ← { i} ▷ start message contains collect 33: broadcast(0, ⟨collect i⟩i) 34: while true do 35: cached ← minimum-saved( auxnum ) ▷ check if there is a saved snapshot 36: if cached ̸ = ⊥ then return cached 37: p ← (p + 1) mod n + 1 ▷ deliver messages in round robin 38: m ← deliver( p, rts i[p]) ▷ deliver next message from p 39: if m = ⊥ then continue 40: if rts i[p]= 0 and m contains a signed collect array c then ▷ start message (round 0) 41: σ ← σ ∪ { m} 42: update-collect( c) 43: senders i ← senders i ∪ { j} 44: else if m contains a signed set of processes, jsenders then ▷ round r message for r > 0 45: if jsenders ⊈ senders i then 46: continue ▷ cannot process message, its dependencies are missing 47: σ ← σ ∪ { m} 48: seen i[j][ rts i[p]] ← jsenders ∪ seen i[j][ rts
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
i[p] − 1] 49: rts i[p] ← rts i[p] + 1 50: if received f + 1 round-r messages for the first time then 51: r ← r + 1 52: broadcast( r, ⟨senders i⟩i) 53: if ∃s s.t. |{ j| seen i[j][ s] = senders i}| = f + 1 then ▷ stability condition 54: r ← 0 55: senders i← ∅ 56: ∀j ∈ [n], k ∈ N, seen i[j][k] ← ∅ 57: cached ← minimum-saved( auxnum ) ▷ re-check for saved snapshot 58: if cached ̸ = ⊥ then return cached 59: savesnap i[auxnum ] ← ⟨ collect i, σ ⟩ ▷ σ contains all received messages in this snapshot-aux instance 60: return collect i D I S C 2 0 2 1 18:14 Tame the Wild with Byzantine Linearizability During the execution, a correct processes delivers messages from all other processes in a round robin fashion. The local variable p represents the process from which it currently delivers. In addition, rts [p] maintains the next timestamp to be delivered from p (lines 38, 49, 37). Note that if the delivered message at some point is ⊥, rts [p] is not increased, so all of p’s messages are delivered in order (line 39). Snapshot-aux proceeds in rounds, which are reflected in the timestamps of the messages broadcast during its execution. Each correct process starts snapshot-aux at round 0, where it broadcasts its collected array; we refer to this as its start message. It then continues to round r + 1 once it has delivered f + 1 round r messages (line 51). Each process maintains a local set senders that contains the processes from which it received start messages (line 43). In every round (from 1 onward) processes send the set of processes from which they received
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
start messages (line 52). Process i maintains a local map seen [j][ r] that maps a process j and a round r to the set of processes that j reported to have received start messages from in rounds 1–r (line 48), but only if i has received start messages from all the reported processes (line 45). By doing so, we ensure that if for some correct process i and a round r seen i[j][ r] contains a process l, l is also in senders i. If this condition is not satisfied, the delivered counter for j (rts [j]) is not increased and this message will be repeatedly delivered until the condition is satisfied. Once there is a process i such that there exists a round s and there is a set S of f + 1 processes j for which seen i[j][ s] is equal to senders i, we say that the stability condition at line 53 is satisfied for S. At that time, i and f more processes agree on the collected arrays sent at round 0 by processes in senders i, and collect i holds the supremum of those collected arrays. This is because whenever it received a start message, it updated its collect so that currently collect i reflects all collects sent by processes in senders i. Thus, i can return its current collect as the snapshot-aux result. Since reliable broadcast prevents Byzantine processes from equivocating, there are f more processes that broadcast the same senders set at that round, and any future round will “see” this set. As we later show, after at most n + 1 rounds, the stability condition holds and hence the size of seen is O(n3). Together with the collected arrays, the total space complexity is cubic in n.To ensure liveness in
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
case some correct processes complete a snapshot-aux instance before all do, we add a helping mechanism. Whenever a correct process successfully completes snapshot-aux, it stores its result in a savesnap map, with the auxnum as the key (either at line 24 or at line 59). This way, once one correct process returns from snapshot-aux, others can read its result at line 35 and return as well. To prevent Byzantine processes from storing invalid snapshots, each entry in the savesnap map is a tuple of the returned array and a proof of the array’s validity. The proof is the set of messages received by the process that stores its array in the current instance of snapshot-aux. Using these messages, correct processes can verify the legitimacy of the stored array. If a correct process reads from savesnap a tuple with an invalid proof, it simply ignores it. # 7.3 Correctness We outline the key correctness arguments highlighting the main lemmas. Formal proofs of these lemmas appear in the full version [ 14 ]. To prove our algorithm is Byzantine linearizable, we first show that all returned snapshots are totally ordered (by coordinate-wise order): ▶ Lemma 9. If two snapshot operations invoked by correct processes return si and sj , then sj ≥ si or sj < s i.S. Cohen and I. Keidar 18:15 Based on this order, we define a linearization. Then, we show that our linearization preserves real-time order, and it respects the sequential specification. We construct the linearization E as follows: First, we linearize all snapshot operations of correct processes in the order of their return values. Then, we linearize every update operation by a correct process immediately before the first snapshot operation that “sees” it. We say that a snapshot returning s sees an update by process j that
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
has timestamp ts if s[j].ts ≥ ts . If multiple updates are linearized to the same point (before the same snapshot), we order them by their start times. Finally, we add updates by Byzantine processes as follows: We add update(v) by a Byzantine process j if there is a linearized snapshot that returns s and s[j].val = v. We add the update immediately before any snapshot that sees it. We next prove that the linearization respects the sequential specification. ▶ Lemma 10. The ith entry of the array returned by a snapshot invocation contains the value v last updated by an update(v) invoked by process i in E, or its variable’s initial value if no update was invoked. Because an update is linearized immediately before some snapshot sees it and snapshots are monotonically increasing, all following snapshots see the update as well. Next, we prove in the two following lemmas that E preserves the real-time order. ▶ Lemma 11. If a snapshot operation invoked by a correct process i with return value si precedes a snapshot operation invoked by a correct process j with return value sj , then si ≤ sj . ▶ Lemma 12. Let s be the return value of a snapshot operation snap i invoked by a correct process i. Let update j (v) be an update operation invoked by a correct process j that writes ⟨ts, v ⟩ and completes before snap i starts. Then, s[j].ts ≥ ts . It follows from Lemma 12 and the definition of E, that if an update precedes a snapshot it is linearized before it, and from Lemma 11 that if a snapshot precedes a snapshot it is also linearized before it. The following lemma ensures that if an update precedes another update it is linearized before it. That
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
is, if a snapshot operation sees the second update, it sees the first one. ▶ Lemma 13. If update1 by process i precedes update2 by process j and a snapshot operation snap by a correct process sees update2, then snap sees update1 as well. Finally, the next lemma proves the liveness of our algorithm. ▶ Lemma 14. (Liveness) Every correct process that invokes some operation eventually returns. We conclude the following theorem: ▶ Theorem 15. Algorithm 2 implements an f -resilient Byzantine linearizable snapshot object for any f 2 . Proof. Lemma 9 shows that there is a total order on snapshot operations. Using this order, we have defined a linearization E that satisfies the sequential specification (Lemma 10). We then proved that E also preserves real-time order (Lemmas 11 – 13). Thus, Algorithm 2 is Byzantine linearizable. In addition, Lemma 14 proves that Algorithm 2 is f -resilient. ◀ D I S C 2 0 2 1 18:16 Tame the Wild with Byzantine Linearizability # 8 Conclusions We have studied shared memory constructions in the presence of Byzantine processes. To this end, we have defined Byzantine linearizability, a correctness condition suitable for shared memory algorithms that can tolerate Byzantine behavior. We then used this notion to present both upper and lower bounds on some of the most fundamental components in distributed computing. We proved that atomic snapshot, reliable broadcast, and asset transfer are all problems that do not have f -resilient emulations from registers when n ≤ 2f . On the other hand, we have presented an algorithm for Byzantine linearizable reliable broadcast with resilience n > 2f . We then used it to implement a Byzantine snapshot with the same resilience. Among other applications, this Byzantine snapshot can be utilized to provide a Byzantine linearizable
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
asset transfer. Thus, we proved a tight bound on the resilience of emulations of asset transfer, snapshot, and reliable broadcast. Our paper deals with feasibility results and does not focus on complexity measures. In particular, we assume unbounded storage in our constructions. We leave the subject of efficiency as an open question for future work. References 1 Ittai Abraham, Gregory Chockler, Idit Keidar, and Dahlia Malkhi. Byzantine disk paxos: optimal resilience with byzantine shared memory. Distributed Computing , 18(5):387–408, 2006. 2 Yehuda Afek, Hagit Attiya, Danny Dolev, Eli Gafni, Michael Merritt, and Nir Shavit. Atomic snapshots of shared memory. Journal of the ACM (JACM) , 40(4):873–890, 1993. 3 Yehuda Afek, David S Greenberg, Michael Merritt, and Gadi Taubenfeld. Computing with faulty shared objects. Journal of the ACM (JACM) , 42(6):1231–1274, 1995. 4 Marcos K Aguilera, Naama Ben-David, Rachid Guerraoui, Virendra Marathe, and Igor Zablotchi. The impact of rdma on agreement. In Proceedings of the 2019 ACM Symposium on Principles of Distributed Computing , pages 409–418, 2019. 5 Marcos K. Aguilera, Naama Ben-David, Rachid Guerraoui, Virendra Marathe, and Igor Zablotchi. The impact of rdma on agreement, 2021. arXiv:1905.12143 . 6 Hagit Attiya, Maurice Herlihy, and Ophir Rachman. Efficient atomic snapshots using lattice agreement. In International Workshop on Distributed Algorithms , pages 35–53. Springer, 1992. 7 Alex Auvolat, Davide Frey, Michel Raynal, and François Taïani. Money transfer made simple: a specification, a generic algorithm, and its proof. Bulletin of EATCS , 3(132), 2020. 8 Mathieu Baudet, Avery Ching, Andrey Chursin, George Danezis, François Garillot, Zekun Li, Dahlia Malkhi, Oded Naor, Dmitri Perelman, and Alberto Sonnino. State machine replication in the libra blockchain. The Libra Assn., Tech. Rep , 2019. 9 Gabriel Bracha. Asynchronous byzantine agreement protocols. Information and Computation ,75(2):130–143, 1987. 10 Christian Cachin, Rachid Guerraoui, and Luís Rodrigues. Introduction to reliable
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
and secure distributed programming . Springer Science & Business Media, 2011. 11 Miguel Castro, Barbara Liskov, et al. A correctness proof for a practical byzantine-fault-tolerant replication algorithm. Technical report, Technical Memo MIT/LCS/TM-590, MIT Laboratory for Computer Science, 1999. 12 Miguel Castro, Barbara Liskov, et al. Practical byzantine fault tolerance. In OSDI , volume 99, pages 173–186, 1999. 13 Vicent Cholvi, Antonio Fernandez Anta, Chryssis Georgiou, Nicolas Nicolaou, and Michel Raynal. Atomic appends in asynchronous byzantine distributed ledgers. In 2020 16th European Dependable Computing Conference (EDCC) , pages 77–84. IEEE, 2020. S. Cohen and I. Keidar 18:17 14 Shir Cohen and Idit Keidar. Tame the wild with byzantine linearizability: Reliable broadcast, snapshots, and asset transfer. arXiv preprint , 2021. arXiv:2102.10597 . 15 Daniel Collins, Rachid Guerraoui, Jovan Komatovic, Petr Kuznetsov, Matteo Monti, Matej Pavlovic, Yvonne-Anne Pignolet, Dragos-Adrian Seredinschi, Andrei Tonkikh, and Athanasios Xygkis. Online payments by merely broadcasting messages. In 2020 50th Annual IEEE/IFIP International Conference on Dependable Systems and Networks (DSN) , pages 26–38. IEEE, 2020. 16 Giuseppe Antonio Di Luna, Emmanuelle Anceaume, and Leonardo Querzoni. Byzantine generalized lattice agreement. In 2020 IEEE International Parallel and Distributed Processing Symposium (IPDPS) , pages 674–683. IEEE, 2020. 17 Rachid Guerraoui, Petr Kuznetsov, Matteo Monti, Matej Pavlovič, and Dragos-Adrian Seredin-schi. The consensus number of a cryptocurrency. In Proceedings of the 2019 ACM Symposium on Principles of Distributed Computing , pages 307–316, 2019. 18 Maurice P Herlihy and Jeannette M Wing. Linearizability: A correctness condition for concurrent objects. ACM Transactions on Programming Languages and Systems (TOPLAS) ,12(3):463–492, 1990. 19 Prasad Jayanti, Tushar Deepak Chandra, and Sam Toueg. Fault-tolerant wait-free shared objects. Journal of the ACM (JACM) , 45(3):451–500, 1998. 20 Barbara Liskov and Rodrigo Rodrigues. Byzantine clients rendered harmless. In International Symposium on Distributed Computing , pages 487–489. Springer, 2005. 21 Jean-Philippe Martin, Lorenzo
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
Alvisi, and Michael Dahlin. Minimal byzantine storage. In International Symposium on Distributed Computing , pages 311–325. Springer, 2002. 22 Achour Mostéfaoui, Matoula Petrolia, Michel Raynal, and Claude Jard. Atomic read/write memory in signature-free byzantine asynchronous message-passing systems. Theory of Com-puting Systems , 60(4):677–694, 2017. 23 Satoshi Nakamoto. Bitcoin: A peer-to-peer electronic cash system. Technical report, Manubot, 2009. 24 Rodrigo Rodrigues and Barbara Liskov. Rosebud: A scalable byzantine-fault-tolerant storage architecture. Technical report, MIT Computer Science and Artificial Intelligence Laboratory, 2003. 25 Gavin Wood et al. Ethereum: A secure decentralised generalised transaction ledger. Ethereum project yellow paper , 151(2014):1–32, 2014. 26 Xiong Zheng and Vijay K. Garg. Byzantine lattice agreement in asynchronous systems. In Quentin Bramas, Rotem Oshman, and Paolo Romano, editors, 24th International Conference on Principles of Distributed Systems, OPODIS 2020, December 14–16, 2020, Strasbourg, France (Virtual Conference) , volume 184 of LIPIcs , pages 4:1–4:16. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2020. doi:10.4230/LIPIcs.OPODIS.2020.4 . # A Byzantine Asset Transfer In this section we adapt the asset transfer implementation from snapshots given in [ 17 ] to a Byzantine asset transfer. The algorithm is very simple. It is based on a shared snapshot array S, with a cell for each client process i, representing i’s outgoing transactions. An additional immutable array holds all processes’ initial balances. A process i’s balance is computed by taking a snapshot of S and applying all of i’s valid incoming and outgoing transfers to i’s initial balance. A transfer invoked by process i checks if i’s balance is sufficient, and if so, appends the transfer details (source, destination, and amount) to i’s cell. Similarly to the use of dependencies in the (message-passing broadcast-based) asset transfer algorithm of , we also track the history of every transaction. To this end, we append to the process’s cell also
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
the snapshot taken to compute the balance for each transaction. D I S C 2 0 2 1 18:18 Tame the Wild with Byzantine Linearizability > Algorithm 4 Byzantine Asset Transfer: code for process i. shared Byzantine snapshot: S initial– immutable array of initial balances local variables: txns i – sets of outgoing transaction, initially {} ts i ∈ N, initially 0 snap – array of sets of transactions, initially array of empty sets ▷ the last snapshot taken struct txn contains :timestamp ts, source src, destination dst, amount amount > 1: procedure balance (j,snap) > 2: incoming ← 0 > 3: outgoing ← 0 > 4: for l ∈ [n] do > 5: for k ∈ snap [l] do > 6: if snap [l][ k].dst = j and valid( snap [l][ k]) then > 7: incoming ← incoming + snap [l][ k].amount > 8: for k ∈ snap [j] do > 9: if valid( snap [j][ k]) then > 10: outgoing ← outgoing + snap [j][ k].amount > 11: return initial (j) + incoming − outgoing > 12: procedure transfer (src,dst,amount) > 13: ts i ← ts i + 1 > 14: snap ← S.snapshot () > 15: if balance (src, snap ) 16: return false > 17: txns i ← txns i.append (⟨ts i, src, dst, amount, snap ⟩i) > 18: S.update (txns i) > 19: return true > 20: procedure read (j) > 21: snap ← S.snapshot () > 22: return balance (j, snap )
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
Title: The consensus number of a cryptocurrency (extended version) URL Source: Markdown Content: > Distributed Computing # The consensus number of a cryptocurrency (extended version) Rachid Guerraoui 1 · Petr Kuznetsov 2 · Matteo Monti 1 · Matej Pavlovic 1 · Dragos-Adrian Seredinschi 1 > Received: 10 February 2020 / Accepted: 3 June 2021 © The Author(s) 2021 Abstract Many blockchain-based algorithms, such as Bitcoin, implement a decentralized asset transfer system, often referred to as a cryptocurrency. As stated in the original paper by Nakamoto, at the heart of these systems lies the problem of preventing double-spending; this is usually solved by achieving consensus on the order of transfers among the participants. In this paper, we treat the asset transfer problem as a concurrent object and determine its consensus number, showing that consensus is, in fact, not necessary to prevent double-spending. We first consider the problem as defined by Nakamoto, where only a single process—the account owner—can withdraw from each account. Safety and liveness need to be ensured for correct account owners, whereas misbehaving account owners might be unable to perform transfers. We show that the consensus number of an asset transfer object is 1. We then consider a more general k-shared asset transfer object where up to k processes can atomically withdraw from the same account, and show that this object has consensus number k. We establish our results in the context of shared memory with benign faults, allowing us to properly understand the level of difficulty of the asset transfer problem. We also translate these results in the message passing setting with Byzantine players, a model that is more relevant in practice. In this model, we describe an asynchronous Byzantine fault-tolerant asset transfer implementation that is both simpler and more efficient than state-of-the-art consensus-based solutions. Our
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
results are applicable to both the permissioned (private) and permissionless (public) setting, as normally their differentiation is hidden by the abstractions on top of which our algorithms are based. Keywords Distributed computing · Cryptocurrency · Consensus · Blockchain · Decentralized payments # 1 Introduction The Bitcoin protocol, introduced in 2008 by Satoshi Nakamoto, implements a cryptocurrency : an electronic decentralized asset transfer system . Since then, many alternatives to Bitcoin came to prominence. These include major cryp- # B Matej Pavlovic matopavlovic@gmail.com Rachid Guerraoui rachid.guerraoui@epfl.ch Petr Kuznetsov petr.kuznetsov@telecom-paristech.fr Matteo Monti matteo.monti@epfl.ch Dragos-Adrian Seredinschi dragos-adrian.seredinschi@epfl.ch 1 École Polytechnique Fédérale de Lausanne (EPFL), Lausanne, Switzerland 2 LTCI, Télécom Paris, Institut Polytechnique de Paris, Paris, France tocurrencies such as Ethereum or Ripple , as well as systems sparked from research or industry efforts such as Bitcoin-NG , Algorand , ByzCoin , Stellar , Hyperledger Fabric , Corda , or Solida . Each alternative brings novel approaches to implementing decentralized transfers, and sometimes offers a more general interface (known as smart contracts ) than the original protocol proposed by Nakamoto. They improve over Bitcoin in various aspects, such as performance, energy-efficiency, or security. A common theme in these protocols, whether they are for basic transfers or smart contracts , is that they seek to implement a blockchain —a distributed ledger where all the transfers in the system are totally ordered. Achieving total order among multiple inputs (e.g., transfers) is fundamen-tally a hard task, equivalent to solving consensus [27,29]. Consensus , a central problem in distributed computing, is known for its notorious difficulty. It has no deterministic solution in asynchronous systems if just a single participant can fail . Partially synchronous consensus algorithms are # 123 R. Guerraoui et al. tricky to implement correctly [1,12,15] and face tough trade-offs between performance, security, and
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
energy-efficiency [5,8,25,47]. Not surprisingly, the consensus module is a major bottleneck in blockchain-based protocols [28,43,47]. A close look at Nakamoto’s original paper reveals that the central issue in implementing a decentralized asset transfer system (i.e., a cryptocurrency) is preventing double-spending , i.e., spending the same money more than once . Bitcoin and numerous follow-up systems typically assume that total order—and thus consensus—is vital to preventing double-spending . There seems to be a common belief, indeed, that a consensus algorithm is essential for implement-ing decentralized asset transfers [9,25,32,39]. In this paper, we first show that consensus is not necessary to implement asset transfer in the shared memory model. We do so by casting the asset transfer problem as a sequential object type and determining that it has consensus number 1 in Herlihy’s hierarchy . 1 We then use the insight provided by our result in the shared memory model—namely that pro-cesses do not need to establish total order on operations for asset transfer—to implement a fully asynchronous protocol that indeed implements asset transfer in the Byzantine mes-sage passing model without solving consensus. The intuition behind this result is the following. An asset transfer object maintains a set of accounts. Each account is associated with an owner process that is the only one allowed to issue transfers withdrawing from this account. Every pro-cess can, however, read the balance of any account. The main insight here is that relating accounts to unique owners obviates the need for consensus. It is the owner that decides on the order of transfers from its own account, without the need to agree with any other process—thus the consensus number 1. Other processes only validate the owner’s decisions, ensuring that causal relations across accounts are respected. We describe a simple asset transfer implementation using atomic-snapshot memory . A
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
with-drawal from an account is validated by relating the withdrawn amount with the incoming transfers found in the memory snapshot. Intuitively, as at most one withdrawal can be active on a given account at a time (as the account’s owner is a single sequential process), it is safe to declare the validated opera-tion as successful and post it in the snapshot memory. We also present a natural generalization of our result to the setting in which multiple processes are allowed to with-draw from the same account. A k-shared asset-transfer object allows up to k processes to execute outgoing transfers from the same account. We prove that such an object has consen-sus number k and thus allows for implementing state machine replication (now often referred to as smart contracts ) among 1 The consensus number of an object type is the maximal number of processes that can solve consensus using only read-write shared mem-ory and arbitrarily many objects of this type. the k involved processes using k-consensus objects . We show that k-shared asset transfer has consensus number k by reducing it to k-consensus (known to have consensus number k) and reducing k-consensus to asset transfer. Studying the asset transfer problem in shared memory under crash faults provides crucial insight into the inherent synchronization complexity of the problem itself. Strictly speaking, however, results obtained in this model do not directly transfer to the (much more demanding) message passing model with Byzantine faults, under which most prac-tical cryptocurrency systems operate. Building on the intuitions from the shared memory model, we also present a practical solution to this problem in the setting of Byzantine fault-prone processes communicating via message passing. This setting matches realistic deploy-ments of distributed systems. We describe an asset transfer implementation that does not resort to consensus. Instead, the implementation
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
relies on a secure broadcast primitive that ensures uniform reliable delivery with only weak ordering guarantees [36,37], circumventing hurdles imposed by con-sensus. In the k-shared case, our results imply that to execute some form of smart contract involving k users, consensus is only needed among these k nodes and not among all nodes in the system. In particular, should these k nodes be faulty, the rest of the accounts will not be affected. To summarize, we argue that treating the asset transfer problem as a concurrent data structure and measuring its hardness through the lens of distributed computing helps to understand it and devise better solutions to it. The rest of this paper is organized as follows. We first give the formal definition of the shared memory model and the asset transfer object type (Sect. 2). Then, we show that this object type has consensus number 1 (Sect. 3). Next, we generalize our result by proving that a k-shared asset transfer object has consensus number k (Sect. 4). Finally, we describe the implications of our results in the message passing model with Byzantine faults (Sects. 5 and 6) and discuss related work (Sect. 7). # 2 Shared memory model and asset-transfer object type We now present the shared memory model (Sect. 2.1) and precisely define the problem of asset-transfer as a sequential object type (Sect. 2.2). 2.1 Definitions Processes. We assume a set Π of N asynchronous processes that communicate by invoking atomic operations on shared memory objects. Processes are sequential—we assume that # 123 The consensus number of a cryptocurrency (extended version) a process never invokes a new operation before obtaining a response from a previous one. Object types. A sequential object type is defined as a tuple T = (Q, q0, O, R, Δ) , where Q is
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
a set of states, q0 ∈ Q is an initial state, O is a set of operations, R is a set of responses and Δ ⊆ Q × Π × O × Q × R is a relation that associates a state, a process identifier and an operation to a set of possible new states and corresponding responses. We assume that Δ is total on the first three elements. A history is a sequence of invocations and responses, each invocation or response associated with a process identifier. A sequential history is a history that starts with an invocation and in which every invocation is immediately followed with a response associated with the same process. A sequential history is legal if its invocations and responses respect the relation Δ for some sequence of state assignments. Implementations. An implementation of an object type T is a distributed algorithm that, for each process and invoked operation, prescribes the actions that the process needs to take to perform it. An execution of an implementation is a sequence of events : invocations and responses of operations or atomic accesses to shared abstractions. The sequence of events at every process must respect the algorithm assigned to it. Failures. Processes are subject to crash failures (we con-sider more general Byzantine failures in Sect. 5). A process may halt prematurely, in which case we say that the process has crashed . A process is called faulty if it crashes during the execution. A process is correct if it is not faulty. All algorithms we present in the shared memory model are wait-free —every correct process eventually returns from each operation it invokes, regardless of an arbitrary number of other processes crashing or concurrently invoking opera-tions. Linearizability. For each pattern of operation invocations, the execution produces a history ,
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
i.e., a sequence of distinct invocations and responses, labelled with process identifiers and unique sequence numbers. A projection of a history H to process p, denoted H | p is the subsequence of elements of H labelled with p. An invocation o by a process p is incomplete in H if it is not followed by a response in H | p. A history is complete if it has no incomplete invocations. A completion of H is a history ¯H that is identical to H except that every incomplete invocation in H is either removed or completed by inserting a matching response somewhere after it. An invocation o1 precedes an invocation o2 in H , denoted o1 ≺H o2 , if o1 is complete and the corresponding response r1 precedes o2 in H . Note that ≺H stipulates a partial order on invocations in H . A linearizable implementation (also said an atomic object ) of type T ensures that for every history H it produces, there exists a completion ¯H and a legal sequential history S such that (1) for all processes p, ¯H | p = S| p and (2) ≺H ⊆≺ S . Consensus number. The problem of consensus consists for a set of processes to propose values and decide on the proposed values so that no two processes decide on differ-ent values and every correct process decides. The consensus number of a type T is the maximal number of processes that can solve consensus using atomic objects of type T and read-write registers. 2.2 The asset transfer object type Let A be a set of accounts and μ : A → 2Π be an “owner” map that associates each account with a set of processes that are, intuitively, allowed to debit the account. We define the
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
asset-transfer object type associated with A and μ as a tuple (Q, q0, O, R, Δ) , where: – The set of states Q is the set of all possible maps q : A → N. Intuitively, each state of the object assigns each account its balance .– The initialization map q0 : A → N assigns the initial balance to each account. – Operations and responses of the type are defined as O ={transfer (a, b, x) : a, b ∈ A, x ∈ N} ∪ { read (a) : a ∈ A} and R = { true , false } ∪ N.– Δ is the set of valid state transitions. For a state q ∈ Q,a process p ∈ Π, an operation o ∈ O, a response r ∈ R and a new state q′ ∈ Q, the tuple (q, p, o, q′, r) ∈ Δ if and only if one of the following conditions is satisfied: – o = transfer (a, b, x) ∧ p ∈ μ( a) ∧ q(a) ≥ x ∧ q′(a) = q(a) − x ∧ q′(b) = q(b) + x ∧ ∀ c ∈ A \ { a, b} : q′(c) = q(c) (all other accounts unchanged) ∧ r = true ; In other words, operation transfer (a, b, x) invoked by process p succeeds if and only if p is the owner of the source account a and account a has enough balance, and if it does, x is transferred from a to the destination account b. We call a transfer (a, b, x) operation outgoing for a and incoming for b; respectively, the x units are called out-going for a and incoming for b. The response being true we call the transfer successful .– o = transfer (a, b, x) ∧
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
( p /∈ μ( a) ∨ q(a) < x) ∧ q′ = q ∧ r = false ;A transfer fails (having false as response) without modifying the state ( q′ = q) if the invoking process is not the owner of account a or if a has insufficient balance. – o = read (a) ∧ q = q′ ∧ r = q(a).Operation read (a) simply returns the balance of a and leaves the account balances untouched. # 123 R. Guerraoui et al. Our model of the asset-transfer object defines a static number of participants and their accounts. Initial balances are also part of the object definition. In practice, such a model is closer to private/permissioned blockchain systems than to public/permissionless ones. Bootstrapping and dynamic reconfiguration of the accounts and membership are out of the scope of this paper. We believe, however, that our model of asset transfer serves a solid base for extensions addressing these issues. As in Nakamoto’s original paper , we assume for the moment that an asset-transfer object has at most one owner per account: ∀a ∈ A : | μ( a)| ≤ 1. Later we lift this assumption and consider more general k-shared asset-transfer objects with arbitrary owner maps μ (Sect. 4). For the sake of simplicity, we also restrict ourselves to trans-fers with a single source account and a single destination account. However, our definition (and implementation) of the asset-transfer object type can trivially be extended to sup-port transfers with multiple source accounts (all owned by the same sequential process) and multiple destination accounts. # 3 Asset transfer has consensus number 1 In this section, we show that the asset-transfer type can be wait-free implemented using only an atomic snapshot object . Since atomic snapshot has consensus number 1 (i.e., can be implemented on top
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
of read-write registers in a shared memory system with crash failures) , it follows that the asset-transfer type also has consensus number 1. Consider an asset-transfer object associated with a set of accounts A and an ownership map μ where ∀a ∈ A, |μ( a)| ≤ 1. Our implementation is described in Fig. 1. Every process p is associated with a distinct location in an atomic snapshot object storing the set of all successful transfer operations executed by p so far. Since each account is owned by at most one process, all outgoing transfers for an account appear in a single location of the atomic snapshot (associated with the owner process). Recall that the atomic snapshot (AS) memory is repre-sented as a vector of N shared variables that can be accessed with two atomic operations: update and snapshot . An update operation modifies the value at a given position of the vec-tor and a snapshot returns the state of the whole vector. We implement the read and transfer operations as follows. – To read the balance of an account a, the process simply takes a snapshot S and returns the initial balance plus the sum of incoming amounts minus the sum of all outgoing amounts. We denote this number by balance (a, S). As we argue below, the result is guaranteed to be non-negative, > Fig. 1 Wait-free implementation of asset-transfer : code for process p i.e., the implementation is correct with respect to the type specification. – To perform transfer (a, b, x), a process p, the owner of a, takes a snapshot S and computes balance (a, S). If the amount to be transferred does not exceed balance (a, S),we add the transfer operation to the set of p’s operations in the snapshot object via an update
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
operation and return true . Otherwise, the operation returns false . Theorem 1 The asset-transfer object type has a wait-free implementation in the read-write shared memory model. Proof Fix an execution E of the algorithm in Fig. 1. Atomic snapshots can be wait-free implemented in the read-write shared memory model . As every operation only involves a finite number of atomic snapshot accesses, every process completes each of the operations it invokes in a finite number of its own steps. Let Ops be the set of: – All invocations of transfer or read in E that returned, and – All invocations of transfer in E that completed the update operation (line 5). Let H be the history of E. We define a completion of H and, for each o ∈ Ops , we define a linearization point as follows: – If o is a read operation, it linearizes at the linearization point of the snapshot operation in line 7. – If o is a transfer operation that returns false , it linearizes at the linearization point of the snapshot operation in line 1. # 123 The consensus number of a cryptocurrency (extended version) – If o is a transfer operation that completed the update operation, it linearizes at the linearization point of the update operation in line 5. If o is incomplete in H , we complete it with response true .Let ¯H be the resulting complete history and let L be the sequence of complete invocations of ¯H in the order of their linearization points in E. Note that, by the way we linearize invocations, the linearization of a prefix of E is a prefix of L.Now we show that L is legal and, thus, H is linearizable. We proceed by induction, starting with the empty (trivially legal) prefix
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
of L. Let L be the legal prefix of the first invocations and op be the ( + 1)st operation of L. Let op be invoked by process p. The following cases are possible: – op is a read (a): the snapshot taken at the linearization point of op contains all successful transfers concerning a in L. By the induction hypothesis, the resulting balance is non-negative. – op is a failed transfer (a, b, x): the snapshot taken at the linearization point of op contains all successful trans-fers concerning a in L. By the induction hypothesis, the resulting balance is non-negative. – op is a successful transfer (a, b, x): by the algorithm, before the linearization point of op , process p took a snapshot. Let L k , k ≤ , be the prefix of L that only con-tain operations linearized before the point in time when the snapshot was taken by p.We observe that L k includes a subset of all incoming transfers on a and all outgoing transfers on a in L.Indeed, as p is the owner of a and only the owner of a can perform outgoing transfers on a, all outgoing transfers in L were linearized before the moment p took the snapshot within op . Thus, balance (a, L k ) ≤ balance (a, L ). 2By the algorithm, as op = transfer (a, b, x) succeeds, we have balance (a, L k ) ≥ x. Thus, balance (a, L ) ≥ x and the resulting balance in L+1 is non-negative. Thus, H is linearizable. Corollary 1 The asset-transfer object type has consensus number 1. # 4 k-shared asset transfer has consensus number k We now consider the case with an arbitrary owner map μ.We show that an asset-transfer object’s consensus number
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
is 2 Analogously to balance (a, S) that computes the balance for account > abased on the transfers contained in snapshot S,balance (a,L), if Lis a sequence of operations, computes the balance of account abased on all transfers in L. > Fig. 2 Wait-free implementation of consensus among kprocesses using ak-shared asset-transfer object. Code for process p∈ { 1, . . . , k} the maximal number of processes sharing an account. More precisely, the consensus number of an asset-transfer object is max a∈A |μ( a)|.We say that an asset-transfer object, defined on a set of accounts A with an ownership map μ, is k-shared iff max a∈A |μ( a)| = k. In other words, the object is k-shared if μ allows at least one account to be owned by k processes, and no account is owned by more than k processes. We show that the consensus number of any k-shared asset-transfer object is k, which generalizes our result in Corollary 1. We first show that such an object has consensus number at least k by implementing consensus for k processes using only registers and an instance of k-shared asset-transfer . We then show that k-shared asset-transfer has consensus number at most k by reducing it to k-consensus, an object known to have consensus number k . Lemma 1 Consensus has a wait-free implementation for k processes in the read-write shared memory model equipped with a single k-shared asset-transfer object. Proof We now provide a wait-free algorithm that solves consensus among k processes using only registers and an instance of k-shared asset-transfer . The algorithm is described in Fig. 2. Intuitively, k processes use one shared account a to elect one of them whose input value will be decided. Before a process p accesses the shared account, p announces its
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
input in a register (line 1). Process p then tries to perform a transfer from account a to another account. The amount withdrawn this way from account a is chosen specifically such that: – only one transfer operation can ever succeed, and – if the transfer succeeds, the remaining balance on a will uniquely identify process p.To satisfy the above conditions, we initialize the balance of account a to 2 k and have each process p ∈ { 1, . . . , k} transfer 2k − p (line 2). Note that transfer operations invoked by distinct processes p, q ∈ { 1, . . . , k} have arguments 2 k − p # 123 R. Guerraoui et al. and 2 k−q, and 2 k− p+2k−q ≥ 2k−k+2k−(k−1) = 2k+ 1. The initial balance of a is only 2 k and no incoming transfers are ever executed. Therefore, the first transfer operation to be applied to the object succeeds (no transfer tries to withdraw more then 2 k) and the remaining operations will have to fail due to insufficient balance. When p reaches line 3, at least one transfer must have suc-ceeded: – either p’s transfer succeeded, or – p’s transfer failed due to insufficient balance, in which case some other process must have previously succeeded. Let q be the process whose transfer succeeded. Thus, the bal-ance of account a is 2 k − (2k − q) = q. Since q performed a transfer operation, by the algorithm, q must have previ-ously written its proposal to the register R[q]. Regardless of whether p = q or p = q, reading the balance of account a returns q and p decides the value of R[q]. To prove that k-shared asset-transfer has consensus number at most k, we reduce
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
k-shared asset-transfer to k-consensus. A k-consensus object exports a single opera-tion propose that, the first k times it is invoked, returns the argument of the first invocation. All subsequent invocations return ⊥. Given that k-consensus is known to have consensus number exactly k , a wait-free algorithm implementing k-shared asset-transfer using only registers and k-consensus objects implies that the consensus number of k-shared asset-transfer is not more than k.The algorithm reducing k-shared asset-transfer to k-consensus is given in Fig. 3. Before presenting a formal correctness argument, we first informally explain the intu-ition of the algorithm. In our reduction, we associate a series of k-consensus objects with every account a. Up to k own-ers of a use the k-consensus objects to agree on the order of outgoing transfers for a.We maintain the state of the implemented k-shared asset-transfer object using an atomic snapshot object AS . Every process p uses a distinct entry of AS to store a set hist . hist is a subset of all completed outgoing transfers from accounts that p owns (and thus is allowed to debit). For example, if p is the owner of accounts d and e, p’s hist contains outgo-ing transfers from d and e. Each element in the hist set is represented as (( a, b, x, s, r), result ), where a, b, and x are the respective source account, destination account, and the amount transferred, s is the originator of the transfer, and r is the round in which the transfer was invoked by the origina-tor. The value of result ∈ { success , failure } indicates whether the transfer succeeds or fails. A transfer becomes “visible” when any process inserts it in its corresponding entry of AS . > Fig. 3 Wait-free implementation of a k-shared asset-transfer object using k-consensus
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
objects. Code for process p To read the balance of account a, a process takes a snapshot of AS , and then sums the initial balance q0(a) and amounts of all successful incoming transfers, and subtracts the amounts of successful outgoing transfers found in AS . We say that a successful transfer t x is in a snapshot AS (denoted by (t x , success ) ∈ AS ) if there exists an entry e in AS such that (t x , success ) ∈ AS [e]. # 123 The consensus number of a cryptocurrency (extended version) To execute a transfer o outgoing from account a, a process p first announces o in a register R a that can be written by p and read by any other process. This enables a “helping” mechanism needed to ensure wait-freedom to the owners of a . Next, p collects the transfers proposed by other owners and tries to agree on the order of the collected transfers and their results using a series of k-consensus objects. For each account, the agreement on the order of transfer-result pairs proceeds in rounds. Each round is associated with a k-consensus object which p invokes with a proposal chosen from the set of collected transfers. Since each process, in each round, only invokes the k-consensus object once, no k-consensus object is invoked more than k times and thus each invocation returns a value (and not ⊥). A transfer-result pair as a proposal for the next instance of k-consensus is chosen as follows. Process p picks the “old-est” collected but not yet committed operation (based on the round number round a attached to the transfer operation when a process announces it; ties are broken using process IDs). Choosing the oldest operation ensures wait-freedom by pre-venting a process from
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
indefinitely helping other processes, given only a finite number of possible older operations pro-posed by other processes. Then, p takes a snapshot of AS and checks whether account a has sufficient balance according to the state rep-resented by the snapshot, and equips the transfer with a corresponding success / failure flag. The resulting transfer-result pair constitutes p’s proposal for the next instance of k-consensus. The currently executed transfer by process p returns as soon as it is decided by a k-consensus object, the flag of the decided value ( success /failure ) indicat-ing the transfer’s response ( true /false ). Lemma 2 The k-shared asset-transfer object type has a wait-free implementation in the read-write shared memory model equipped with k-consensus objects. Proof We essentially follow the footpath of the proof of The-orem 1. Fix an execution E of the algorithm in Fig. 3. Let H be the history of E.To perform a transfer o on an account a, p registers it in R a [ p] (line 4) and then proceeds through a series of k-consensus objects, each time collecting R a to learn about the transfers concurrently proposed by other owners of a.Recall that each k-consensus object is wait-free. Suppose, by contradiction, that o is registered in R a but is never decided by any instance of k-consensus. Eventually, however, o becomes the request with the lowest round number in R a and, thus, some instance of k-consensus will be only accessed with o as a proposed value (line 9). By validity of k-consensus, this instance will return o and, thus, p will be able to complete o.Let Ops be the set of all complete operations and all trans-fer operations o such that some process completed the update operation (line 11) in E with an argument including o (the
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
atomic snapshot and k-consensus operation has been lin-earized). Intuitively, we include in Ops all operations that took effect , either by returning a response to the user or by affecting other operations. Recall that every such transfer operation was agreed upon in an instance of k-consensus, let it be kC o. Therefore, for every such transfer operation o, we can identify the process q o whose proposal has been decided in that instance. We now determine a completion of H and, for each o ∈ Ops , we define a linearization point as follows: – If o is a read operation, it linearizes at the linearization point of the snapshot operation (line 19). – If o is a transfer operation that returns false , it linearizes at the linearization point of the snapshot operation (line 8) performed by q o just before it invoked kC o.propose () .– If o is a transfer operation that some process included in the update operation (line 11), it linearizes at the lin-earization point of the first update operation in H (line 11) that includes o. Furthermore, if o is incomplete in H , we complete it with response q o determined before propos-ing o (line 8). Let ¯H be the resulting complete history and let L be the sequence of complete operations of ¯H in the order of their linearization points in E. Note that, by the way we linearize operations, the linearization of a prefix of E is a prefix of L.Also, by construction, the linearization point of an operation belongs to its interval. Now we show that L is legal and, thus, H is linearizable. We proceed by induction, starting with the empty (trivially legal) prefix of L. Let L be the legal prefix of the first operation and op
|
{
"page_id": null,
"source": 7322,
"title": "from dpo"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.