Start / Algorithms + Data Structures = Programs / Episode 124 vectorizing stdviewsfilter

Episode 124: Vectorizing std::views::filter

42 min • 7 april 2023

In this episode, Conor and Bryce talk about vectorizing std::views::filter.

Link to Episode 124 on Website
Discuss this episode, leave a comment, or ask a question (on GitHub)

Twitter

ADSP: The Podcast
Conor Hoekstra
Bryce Adelstein Lelbach

Show Notes

Date Recorded: 2023-03-21
Date Released: 2023-04-07

YouTube Video of this episode
Spaces Prototype Godbolt Link
MD Iteration Comparison Godbolt Link
Ranges Vectorization Brainstorming Godbolt Link
Minimal Filter Vectorization Example #0 Godbolt Link
Minimal Filter Vectorization Example #1 Godbolt Link
C++20 std::views::filter
Auto-Vectorization in LLVM
C++20 std::ranges::replace_if
C++20 std::views::transform
Bryce’s spaces/view_optimization.hpp
P0931 Structured bindings with polymorphic lambas
C++20 std::views::take
C++20 std::views::drop

Intro Song Info

Miss You by Sarah Jansen https://soundcloud.com/sarahjansenmusic
Creative Commons — Attribution 3.0 Unported — CC BY 3.0
Free Download / Stream: http://bit.ly/l-miss-you
Music promoted by Audio Library https://youtu.be/iYYxnasvfx8

Senaste avsnitt

Episode 161: 🎄 EOP, Rust, Hylo, C++20/23/26/29 & More with Zach Laine (Holiday Special #4)

22 december 2023 | 105 min

Episode 160: Rust & Safety at Adobe with Sean Parent

15 december 2023 | 39 min

Episode 159: The Roc Programming Language with Richard Feldman (Part 3)

8 december 2023 | 29 min

Episode 158: The Roc Programming Language with Richard Feldman (Part 2)

1 december 2023 | 33 min

Episode 157: The Roc Programming Language with Richard Feldman

24 november 2023 | 29 min

Episode 156: The Last Strange Loop with Richard Feldman

17 november 2023 | 30 min

Episode 155: Don't Hurt Yourself (with C++) with Jonathan O'Connor

10 november 2023 | 36 min

Episode 154: Programming Languages Galore with Jonathan O'Connor

3 november 2023 | 34 min

Episode 153: Pascal vs C vs Ada with Jonathan O'Connor

27 oktober 2023 | 36 min

Episode 152: Ruby in Rwanda with Jonathan O'Connor

20 oktober 2023 | 33 min

Episode 151: Is C++ Dying (Response)

13 oktober 2023 | 36 min

Episode 150: Is C++ Dying?

6 oktober 2023 | 46 min

Episode 149: CityStrides.com, Graph Algorithms and More!

29 september 2023 | 50 min

Episode 148: 🇸🇮 SRT23 - Robert Leahy on C++ in FinTech

22 september 2023 | 34 min

Episode 147: 🇸🇮 SRT23 - Parallel std::unique Revisited (on a Walk in Venice)

15 september 2023 | 30 min

Episode 146: 🇸🇮 SRT23 - Algorithms, BQN's Superpowers & More!

8 september 2023 | 24 min

Episode 145: 🇸🇮 SRT23 - Parallel std::unique

1 september 2023 | 26 min

Episode 144: 🇸🇮 SRT23 - Nigeria, Here We Come! (and How Bryce Almost Died)

25 augusti 2023 | 33 min

Episode 143: 🇸🇮 SRT23 - Hiša Franko, Postojna, Podcasts and R

18 augusti 2023 | 46 min

Episode 142: 🇸🇮 SRT23 - Lake Bled & Bled Cake + Haskell, Rust & C++

11 augusti 2023 | 29 min

Episode 141: 🇨🇦 CppNorth Live 🇨🇦 Kate Gregory, Jessica Kerr & Kristen Shaker!

4 augusti 2023 | 34 min

Episode 140: 🇨🇦 CppNorth Live 🇨🇦 Victor Ciura, Andreas Weis & More!

28 juli 2023 | 42 min

Episode 139: 🇬🇧 Why Sean Parent Joined Adobe

21 juli 2023 | 30 min

Episode 138: 🇬🇧 Sean Parent on Val! (Part 2)

14 juli 2023 | 29 min

Episode 137: 🇬🇧 Sean Parent on Val (vs Rust)!

7 juli 2023 | 32 min

Episode 136: 🇬🇧 C++ On Sea Live 🇬🇧 CppCast, TLB HIT & Two's Complement!

30 juni 2023 | 46 min

Episode 135: 🇸🇮 Slovenia 🇸🇮 2023 Road Trip!

23 juni 2023 | 30 min

Episode 134: 🇵🇱 Lambda Days Live 🇵🇱 Simon Peyton Jones, Jordan Miller & More!

16 juni 2023 | 43 min

Episode 133: 🇵🇱 Lambda Days Live 🇵🇱 José Valim, Alexis King & More!

9 juni 2023 | 35 min

Episode 132: RustConf Drama

2 juni 2023 | 31 min

Episode 131: One Algorithm To Rule Them All!

26 maj 2023 | 43 min

Episode 130: C++Now 2023 with Ben Deane & Tristan Brindle!

19 maj 2023 | 32 min

Episode 129: Circle is Charizard! 🔥

12 maj 2023 | 27 min

Episode 128: GCC 13.1 🥳 and Upcoming Conferences!

5 maj 2023 | 29 min

Episode 127: Flux, ChatGPT & More with Tristan Brindle

28 april 2023 | 35 min

Episode 126: Flux (and Flow) with Tristan Brindle

21 april 2023 | 29 min

Episode 125: NanoRange with Tristan Brindle

14 april 2023 | 28 min

Episode 124: Vectorizing std::views::filter

7 april 2023 | 42 min

Episode 123: An Algorithm Taxonomy

31 mars 2023 | 20 min

Episode 122: ChatGPT, GTC 2023 & Stickers on our Foreheads

24 mars 2023 | 33 min

Episode 121: Stories & Chatting with Zach Laine! (Part 5)

17 mars 2023 | 40 min

Episode 120: C++ Safety, Tuples & Variants with Zach Laine! (Part 4)

10 mars 2023 | 26 min

Episode 119: Why APL & Haskell are AWESOME with Zach Laine! (Part 3)

3 mars 2023 | 32 min

Episode 118: C++ Allocators with Zach Laine! (Part 2)

24 februari 2023 | 32 min

Episode 117: OOP, C++ Containers, APIs, EOP & More with Zach Laine!

17 februari 2023 | 36 min

Episode 116: Max Gap Count in C++23

10 februari 2023 | 29 min

Episode 115: Max Gap in C++23

3 februari 2023 | 26 min

Episode 114: Rust, Val, Carbon, ChatGPT & Errors with Barry Revzin!

27 januari 2023 | 44 min

Episode 113: The C++26 Pipeline Operator with Barry Revzin!

20 januari 2023 | 40 min

Episode 112: 2022 Retro & Running!

13 januari 2023 | 33 min

Episode 111: C++23 Ranges, 2022 Retro & Star Wars

6 januari 2023 | 37 min

Episode CX: Compiler Diagnostics

30 december 2022 | 31 min

Episode 109: Holiday Special #3 - Trees, Travel, Twitter & Terminology!

23 december 2022 | 76 min

Episode 108: Jane Losare-Lusby on Rust! (Part 3)

16 december 2022 | 25 min

Episode 107: Jane Losare-Lusby on Rust! (Part 2)

9 december 2022 | 28 min

Episode 106: Jane Losare-Lusby on Rust!

2 december 2022 | 32 min

Episode 105: Jason Turner from CppCast! (Part 3)

25 november 2022 | 37 min

Episode 104: Jason Turner from CppCast! (Part 2)

18 november 2022 | 35 min

Episode 103: Jason Turner from CppCast!

11 november 2022 | 34 min

Episode 102: Rust scan (vs C++ & Haskell scans)

4 november 2022 | 22 min

Episode 101: C++ Developers Try Rust!

28 oktober 2022 | 23 min

Episode 100: Programming Language Logos, Top 3 C++ Features & More!

21 oktober 2022 | 50 min

Episode 99: Moby Dick & Our Favorite Movies

14 oktober 2022 | 31 min

Episode 98: The Future of C++ with Sean Baxter (Part 2)

7 oktober 2022 | 30 min

Episode 97: C++ vs Carbon vs Circle vs CppFront with Sean Baxter

30 september 2022 | 79 min

Episode 96: The K Programming Language

23 september 2022 | 45 min

Episode 95: Kate Gregory on Carbon vs C++! (Part 4)

16 september 2022 | 31 min

Episode 94: Special Guest Kate Gregory! (Part 3)

9 september 2022 | 28 min

Episode 93: Special Guest Kate Gregory! (Part 2)

2 september 2022 | 33 min

Episode 92: Special Guest Kate Gregory!

26 augusti 2022 | 28 min

Episode 91: C++23 (Part 2)

19 augusti 2022 | 35 min

Episode 90: C++23

12 augusti 2022 | 29 min

Episode 89: The Carbon Programming Language (Part 2)

5 augusti 2022 | 22 min

Episode 88: The Carbon Programming Language

29 juli 2022 | 31 min

Episode 87: Special Guest Tony Van Eerd! (Part 4)

22 juli 2022 | 23 min

Episode 86: Special Guest Tony Van Eerd! (Part 3)

15 juli 2022 | 29 min

Episode 85: Special Guest Tony Van Eerd! (Part 2)

8 juli 2022 | 32 min

Episode 84: Special Guest Tony Van Eerd!

1 juli 2022 | 33 min

Episode 83: 🇺🇸 ARRAY 2022, mdspaces, & More!

24 juni 2022 | 32 min

Episode 82: GPUs - Responding To Reddit Comments

17 juni 2022 | 35 min

Episode 81: C++ Should Leave ISO

10 juni 2022 | 34 min

Episode 80: C++ Multidimensional Arrays and GPUs

3 juni 2022 | 40 min

Episode 79: C++Now 2022, Circle and Clang

27 maj 2022 | 33 min

Episode 78: C++ Algorithms & Profiling with Ben Deane (Part 4)

20 maj 2022 | 33 min

Episode 77: C++ Algorithms & Profiling with Ben Deane (Part 3)

13 maj 2022 | 34 min

Episode 76: C++ Algorithms & Point Free Programming with Ben Deane (Part 2)

6 maj 2022 | 27 min

Episode 75: C++ Algorithms with Ben Deane (Part 1)

29 april 2022 | 27 min

Episode 74: C++ Education, Cats and More! 🐈‍⬛

22 april 2022 | 37 min

Episode 73: CppNorth, Bagels & More!

15 april 2022 | 38 min

Episode 72: C++ Algorithm Family Feud!

8 april 2022 | 40 min

Episode 71: APL, COBOL, BASIC & More

1 april 2022 | 29 min

Episode 70: The Programming Language Quiz

25 mars 2022 | 31 min

Episode 69: Special Guest Andrei Alexandrescu (Part 2)

18 mars 2022 | 30 min

Episode 68: Special Guest Andrei Alexandrescu

11 mars 2022 | 38 min

Episode 67: How to Get Started with C++

4 mars 2022 | 33 min

Episode 66: Exciting C++ News (and Wordle #3)

25 februari 2022 | 28 min

Episode 65: NVIDIA is Hiring! (and Wordle #2)

18 februari 2022 | 29 min

Episode 64: 2022 Preview, Birds & Sponsors!

11 februari 2022 | 38 min

Episode 63: Wordle!

4 februari 2022 | 25 min

Episode 62: 2021 Retro (Part 2)

28 januari 2022 | 43 min

Episode 61: 2021 Retro (Part 1)

21 januari 2022 | 27 min

Episode 60: BQN's After (⟜) and the Parentheses Poll

14 januari 2022 | 27 min

Episode 59: Otto & Eric Niebler! (Part 2)

7 januari 2022 | 35 min

Episode 58: Otto & Eric Niebler! (Part 1)

31 december 2021 | 37 min

Episode 57: Holiday Special #2 - Ljubljana, Here We Come!

24 december 2021 | 48 min

Episode 56: LeetCode in BQN (Part 2)

17 december 2021 | 28 min

Episode 55: LeetCode in C++ (Part 1)

10 december 2021 | 29 min

Episode 54: std::partition in BQN

3 december 2021 | 36 min

Episode 53: Florida & LeetCode

26 november 2021 | 23 min

Episode 52: One Year Anniversary!

19 november 2021 | 36 min

Episode 51: Efficiency vs Speed

12 november 2021 | 30 min

Episode 50: The Great Twitter War: Bryce vs JF

5 november 2021 | 17 min

Episode 49: Special Guest Dave Abrahams! (Part 2)

29 oktober 2021 | 41 min

Episode 48: Special Guest Dave Abrahams!

22 oktober 2021 | 32 min

Episode 47: Combinatory Logic!

15 oktober 2021 | 35 min

Episode 46: Programming Language Awards ~ Coming Soon!

8 oktober 2021 | 19 min

Episode 45: Algebraic Groups and Birds!

1 oktober 2021 | 19 min

Episode 44: Should You Drop Out of School?

24 september 2021 | 46 min

Episode 43: Parallel Scans and Associativity

17 september 2021 | 35 min

Episode 42: Inverse Algorithms and More!

10 september 2021 | 47 min

Episode 41: I Apologize To Listeners

3 september 2021 | 22 min

Episode 40: Star Trek vs PowerPC (with Sean Parent)

27 augusti 2021 | 40 min

Episode 39: How Steve Jobs Saved Sean Parent

20 augusti 2021 | 25 min

Episode 38: Adobe STLab is Back! (with Sean Parent)

13 augusti 2021 | 37 min

Episode 37: std::inclusive_scan

6 augusti 2021 | 33 min

Episode 36: std::transform vs std::for_each

30 juli 2021 | 36 min

Episode 35: SkyNet is Here!

23 juli 2021 | 26 min

Episode 34: Tuples, Arrays, APL & More

16 juli 2021 | 43 min

Episode 33: New York, New York!

9 juli 2021 | 28 min

Episode 32: Hiring Inclusively & Company Culture (Part 4)

2 juli 2021 | 31 min

Episode 31: Strategic Decision Making & More (Part 3)

25 juni 2021 | 28 min

Episode 30: Google, Interviews, Leadership & More (Part 2)

18 juni 2021 | 41 min

Episode 29: From Papa John's to Google (Part 1)

11 juni 2021 | 41 min

Episode 28: Steve Jobs & Sean Parent

4 juni 2021 | 34 min

Episode 27: MacHack & Apple with Sean Parent

28 maj 2021 | 22 min

Episode 26: Sean Parent on Slides Decks, UI & More

21 maj 2021 | 29 min

Episode 25: The Lost Reduction

14 maj 2021 | 64 min

Episode 24: C++Now 2021 with Ben Deane & Tony Van Eerd

7 maj 2021 | 64 min

Episode 23: Algorithms: Anamorphisms!

30 april 2021 | 42 min

Episode 22: Our Favorite Tech TV Shows

23 april 2021 | 44 min

Episode 21: Galaxy Brain Programming Languages

16 april 2021 | 42 min

Episode 20: GTC 2021 Preview & Thrust Algorithms

9 april 2021 | 36 min

Episode 19: Finding Your Way in Tech

2 april 2021 | 47 min

Episode 18: Special Guest Sean Parent! (Part 2)

26 mars 2021 | 37 min

Episode 17: Special Guest Sean Parent!

19 mars 2021 | 40 min

Episode 16: Macros Almighty! (Part 2)

12 mars 2021 | 29 min

Episode 15: Macros Almighty!

5 mars 2021 | 29 min

Episode 14: Inclusive Terminology

26 februari 2021 | 23 min

Episode 13: I'm an Excel Wizard!

19 februari 2021 | 46 min

Episode 12: Formatting && (Parentheses)

12 februari 2021 | 27 min

Episode 11: What belongs in the standard library?

5 februari 2021 | 36 min

Episode 10: snake_case vs camelCase (Naming - Part 3)

29 januari 2021 | 32 min

Episode 9: C++ vs Clojure partition (Naming - Part 2)

22 januari 2021 | 25 min

Episode 8: What's the title? (Naming - Part 1)

15 januari 2021 | 43 min

Episode 7: 2020 Retro (Part 2)

8 januari 2021 | 32 min

Episode 6: 2020 Retro (Part 1) and Fortran

1 januari 2021 | 37 min

Episode 5: Holiday Special - From China to APL

25 december 2020 | 56 min

Episode 4: How Many Programming Languages?

18 december 2020 | 40 min

Episode 3: Our Favorite Data Structures - Part II

11 december 2020 | 31 min

Episode 2: Our Favorite Data Structures

4 december 2020 | 38 min

Episode 1: Our Favorite Algorithms - Part II

27 november 2020 | 34 min

Episode 0: Our Favorite Algorithms

20 november 2020 | 39 min

Episode 124: Vectorizing std::views::filter

Senaste avsnitt

Episode 241: Parallel Algorithm Talk (Part 3)

Episode 240: Thrust, Rust vs C++, Python & More (Part 2)

Episode 239: Claude-Poisoned Dev Sipping Rocket Fuel

Episode 238: Recommended Podcast Discussions on AI & LLMs

Episode 237: Thrust with Jared Hoberock

Episode 236: C++26 Senders and Receivers Algorithms (Part 2)

Episode 235: C++26 Senders and Receivers Algorithms (Part 1)

Episode 234: C++Now 2025 Recap!

Episode 233: AI! Live from Sunnyvale!

Episode 232: Algorithms! Live from New York!

Episode 231: C++26 Senders and Receivers (+ flat_map)

Episode 230: Hoogle Translate

Episode 229: multi_transform? for_each_but_last?

Episode 228: To Tesla or Not to Tesla

Episode 227: Re: The CUDA C++ Developer’s Toolbox

Episode 226: NVIDIA GTC 2017 vs 2025

Episode 225: CppNorth & Flux Plans, The Slow Death of Twitter and More!

Episode 224: Flux Updates & Internal Iteration

Episode 223: Is C++ Dying? II

Episode 222: From Stepanov to Euler to Shawshank

Episode 221: 2025 Predictions, Conferences and More!

Episode 220: Graph Algorithms & 7 Bridges of Königsberg

Episode 219: Flood Fills & Adaptive Mesh Refinement

Episode 218: Algorithms (by Louridas)

Episode 217: Pragmatic vs Inspiring Talks, A Bug and More

Episode 216: Programming Paradigms and Algorithmic Thinking

Episode 215: C++ vs BQN (AoC Part 2)

Episode 214: Advent of Code in BQN (vs Python)

Episode 213: NumPy & Summed-Area Tables

Episode 212: No More AI and Episode 211

Episode 211: Power, Politics and Misconduct in C++ ✨

Episode 210: C++ Cryptic Crossword

Episode 209: Scrabble, Cribbage & More! (Board Games Part 2)

Episode 208: Catan, Codenames & More! (Board Games Part 1)

Episode 207: 🇳🇱 C++ Under the Sea Live 🇳🇱 Mateusz Pusz, Floris Bob & More!

Episode 206: 🇳🇱 C++ Under the Sea Live 🇳🇱 Jason Turner, Inbal Levi & More!

Episode 205: 🇳🇱 C++ Under the Sea Live 🇳🇱 Phil Nash & Jonathan Müller

Episode 204: 🇪🇸 Lambda World Live 🇪🇸

Episode 203: Rotates All the Way Down with Sean Parent (Part 2)

Episode 202: Rotates All the Way Down with Sean Parent (Part 1)

Episode 201: CppCon 2024 Recap!

Episode 200!

Episode 199: std::rotate

Episode 198: Talks ∧ ¬ (Pigeons ∧ Elevators)

Episode 197: 🇬🇧 Algorithms & Tersity with Aaron Hsu

Episode 196: 🇬🇧 Algorithms in APL with Aaron Hsu

Episode 195: 🇨🇦 CppNorth Live 🇨🇦 David Olsen & Pure Chaos!

Episode 194: The One Thing Every Programmer Should Know with Kevlin Henney

Episode 193: Kevlin Henneys with Kevlin Henney

Episode 192: Systems Programming & More with Kevlin Henney

Episode 191: Algorithms & Libraries with Kevlin Henney

Episode 190: C++, Python and More with Kevlin Henney

Episode 189: C++26 Reflection, std::execution & CppNorth

Episode 188: Parallel std::merge

Episode 187: Parallel Top N

Episode 186: How to Get Started in Programming

Episode 185: Name the Algorithm

Episode 184: Safety in Swift 6, Protocols & More with Doug Gregor

Episode 183: Swift with Doug Gregor

Episode 182: C++ Variadic Templates, Swift and More with Doug Gregor

Episode 181: The C++0x Concepts Story with Doug Gregor (Part 2)

Episode 180: The C++0x Concepts Story with Doug Gregor (Part 1)

Episode 179: CheckGrade, ACCU & CppNorth

Episode 178: Henry the Clock, chunk_by & more!

Episode 177: The Couch Episode

Episode 176: 🇺🇸 prior, deltas & Dinner with Phineas

Episode 175: Parallel chunk_by (Part 3)

Episode 174: Parallel chunk_by (Part 2)

Episode 173: Parallel chunk_by

Episode 172: 🇺🇸 Sean Parent on Flash, Chains & Memory Safety

Episode 171: Thinking Parallel & C++ Forward Progress

Episode 170: VIN & HPX

Episode 169: thrust::unique_count and The Algorithm Advisor

Episode 168: Parallel Mode

Episode 167: Phone Tag

Episode 166: Top 20 GPU SDKs, Libraries and Tools!

Episode 165: 2023 Retro! LLMs, Rust vs C++ and More!

Episode 164: Are We Going to Run Out of Credit Cards?