From dff604a6d353ba64f35a5db8c29650cd99027710 Mon Sep 17 00:00:00 2001 From: Matt Mascarenhas Date: Fri, 3 Aug 2018 19:30:57 +0100 Subject: [PATCH] Annotate bitwise054 --- pervognsen/bitwise/bitwise/bitwise054.hmml | 125 ++++++++++++++++++++- 1 file changed, 123 insertions(+), 2 deletions(-) diff --git a/pervognsen/bitwise/bitwise/bitwise054.hmml b/pervognsen/bitwise/bitwise/bitwise054.hmml index 34764d6..ea11ba6 100644 --- a/pervognsen/bitwise/bitwise/bitwise054.hmml +++ b/pervognsen/bitwise/bitwise/bitwise054.hmml @@ -1,2 +1,123 @@ -[video member=pervognsen stream_platform=twitch project=bitwise title="Logic Design, Part 6" vod_platform=youtube id=vbjV_1EBbTg annotator=] -[/video] \ No newline at end of file +[video member=pervognsen stream_platform=twitch project=bitwise title="Logic Design, Part 6" vod_platform=youtube id=vbjV_1EBbTg annotator=Miblo] +[0:06][Recap and set the stage for the day revisiting ALU before going on to shifters][:"logic design" :speech] +[1:18][Review our adders][:"logic design" :research] +[2:37][Review off-stream introduction of Kogge Stone scan][:"logic design" :research] +[4:23][Review off-stream introduction of analyze_delay()][:"logic design" :profiling :research] +[8:04][Instantiate 32-bit and 4-bit bit adders to compare their delay with the 64-bit ones][:"logic design" :performance :run] +[9:57][Shifters][:"logic design" :speech] +[12:23][Set up to implement dynamic shift in terms of static shift][:"logic design" :speech] +[13:42][Introduce left_shifter()][:"logic design"] +[16:50][Define Example16 as a left shifter module][:"logic design"] +[18:47][Check out our left shifter graph][:"debug visualisation" :"logic design" :run] +[19:21][Instantiate a 16-bit shifter and check out its graph][:"debug visualisation" :"logic design" :run] +[20:43][Define Mux4 module][:"logic design"] +[22:43][Introduce left_shifter_radix2() and left_shifter_radix4() based on our original left_shifter()][:"logic design"] +[25:25][Define Example17 using left_shifter_radix4()][:"logic design"] +[25:48][Check out the graph to find that left_shifter_radix4() does not work][:"debug visualisation" :"logic design" :run] +[27:18][Redefine Example17 using just mux4()][:"logic design"] +[27:48][Check out the mux4 graph to see that that works][:"debug visualisation" :"logic design" :run] +[28:00][Fix left_shifter_radix4() to loop over the correct range][:"logic design"] +[28:43][Check out the left_shifter_radix4() graph][:"debug visualisation" :"logic design" :run] +[29:38][Instantiate a 32-bit shifter, and enable left_shifter_radix4() to handle odd-numbered shift bits][:"logic design"] +[31:01][Check out the graph to see that it is not as expected][:"debug visualisation" :"logic design" :run] +[31:22][Change left_shifter_radix4() to handle odd-numbered shift bits inside its loop][:"logic design"] +[32:00][Check out the graph of our 32-bit left shifter][:"debug visualisation" :"logic design" :run] +[32:32][Reflect on our single logarithmic shifter, with a brief mention of linear shifters][:"logic design" :speech] +[33:44][Right-shifting, both logical and arithmetic][:"logic design" :speech] +[35:27][Q&A][:speech] +[35:43][@rygorous][The typical array / linear shifter layout does not have N layers. Instead you basically have N layers "deep" of tristate drivers on one long wire, and only one of them is active, the rest is Z. So that's not N layers deep of logic, basically one layer][:"logic design"] +[36:16][Recommend Mean and Conway's 'Introduction to VLSI systems'[ref + author="Carver Mead and Lynn Conway" + title="Introduction to VLSI systems" + url=https://www.researchgate.net/publication/234388249_Introduction_to_VLSI_systems]][:"logic design" :research] +[37:37][Introduce rotator_radix2][:"logic design"] +[39:41][Define Example18 as a left-rotator][:"logic design"] +[40:09][Instantiate a 16-bit left-rotator and check out its graph][:"debug visualisation" :"logic design" :run] +[41:10][Rename rotator_radix2() to left_rotator_radix2() and introduce right_rotator_radix2() using it][:"logic design"] +[44:15][Introduce __neg__() – unary minus operator – in rattle][:language] +[45:36][Check out our right-rotator graph][:"debug visualisation" :"logic design" :run] +[46:42][Introduce the notion of pre-rotation in right_rotator_radix2()][:"logic design"] +[48:25][Check out our pre-rotated right rotator graph][:"debug visualisation" :"logic design" :run] +[48:32][Test our shifters in the simulator][:emulation :"logic design" :run] +[50:38][Test our rotators in the simulator, introducing rotl() and rotr()][:emulation :"logic design" :run] +[53:37][All the tests passed at the first try][:"logic design" :speech] +[54:43][@rygorous][@pervognsen Probably want to mask both sides for rotl() / rotr() so it works with signed values][:"logic design"] +[54:47][Enable rotl() and rotr() to work with signed values][:"logic design"] +[55:02][Set up to create our first combined design: Barrel shifter][:"logic design" :speech] +[56:32][Introduce barrel_left_shifter()][:"logic design"] +[59:54][Define Example20 as a left barrel shifter][:"logic design"] +[1:00:37][Simulate the left barrel shifter and fail the verification test][:emulation :"logic design" :run] +[1:01:22][Fix missing comma in binary_ops][:language] +[1:01:48][Test the correct module in Example20, and simulate it to find that it passes][:emulation :"logic design" :run] +[1:02:25][@miotatsu][Wow, that implicit string concatenation there is nasty][:language] +[1:02:33][Introduce barrel_right_shifter()][:"logic design"] +[1:05:15][Explain inference of literal types][:language :speech] +[1:06:04][Define Example21 as a right barrel shifter][:"logic design"] +[1:06:32][Simulate the right barrel shifter, fail the test and investigate why][:emulation :"logic design" :run] +[1:14:49][@nothings2][How is it that the outer assertion has access to 'mask'? Is this a weird pythonism?][:language] +[1:15:04][Print the mask of barrel_right_shifter()][:"logic design"] +[1:16:13][:Run it and check out the mask][:emulation :"logic design"] +[1:16:56][Fix the mask computation in barrel_right_shifter()][:"logic design"] +[1:17:11][Simulate the right barrel shifter and pass the test][:emulation :"logic design" :run] +[1:17:19][Remove the mask printout][:"logic design"] +[1:18:11][Simulate it, pass the test and reflect on the right barrel shifter][:emulation :"logic design" :run] +[1:19:06][Introduce barrel_arithmetic_right_shifter()][:"logic design"] +[1:22:02][@rygorous][@pervognsen Don't you really need a mux? Since you need to either clear or set the upper bits, neither AND nor OR by itself can work][:"logic design"] +[1:22:32][Enable barrel_arithmetic_right_shifter() to mux between clearing and setting the upper bits][:"logic design"] +[1:24:54][Simulate the barrel_arithmetic_right_shifter() on a signed input to find that it works][:emulation :"logic design" :run] +[1:25:04][Introduce barrel_shifter() as our first combined design][:"logic design"] +[1:35:34][Define Example23 as a unified barrel shifter][:"logic design"] +[1:37:26][Simulate our unified barrel shifter on left- and right-rotations and left-shift, to find that they all work][:emulation :"logic design" :programming :run] +[1:40:06][Simulate right-shift to find that it doesn't work, and investigate why][:emulation :"logic design" :run] +[1:42:00][Print the mask of barrel_shifter()][:"logic design"] +[1:42:55][@rygorous][@pervognsen But now you're passing in \~n (from the first mux) when dir=1][:"logic design"] +[1:43:05][Enable barrel_shifter() to correctly perform right-shift][:"logic design"] +[1:43:44][Simulate the barrel shifter on right-shift, and pass the test][:emulation :"logic design" :run] +[1:44:05][Simulate the barrel shifter on arithmetic shift, and pass][:emulation :"logic design" :run] +[1:44:40][@rygorous][@pervognsen Basically, for the rotate case, just force mask to all-1s and delete the output mux][:"logic design"] +[1:44:48][Change barrel_shifter() to force the mask to all 1s and delete the output mux in the rotate case][:"logic design"] +[1:45:46][Simulate it to find that it works][:emulation :"logic design" :run] +[1:46:09][Introduce left_rotator_radix4()][:"logic design"] +[1:50:03][Check out the left_rotator_radix4 graph to see that it looks reasonable][:"debug visualisation" :"logic design" :run] +[1:50:33][Instantiate an 8-bit rotator and check out its graph][:"debug visualisation" :"logic design" :run] +[1:52:10][Test barrel_shifter() using both left_rotator_radix2() and left_rotator_radix4() to see that it works][:emulation :"logic design" :programming :run] +[1:53:03][Check out the graph of our unified barrel shifter][:"debug visualisation" :"logic design" :run] +[1:53:20][@rygorous][@pervognsen Why m1, m2, m3 and not m,2*m,3*m?] +[1:53:26][Rewrite left_rotator_radix4() as per @rygorous's suggestion] +[1:53:55][Consult the graph of our unified barrel shifter][:"debug visualisation" :"logic design" :run] +[1:54:34][Instantiate a 16-bit barrel shifter and check out its graph, noting the importance of the mask being off the critical path][:"debug visualisation" :"logic design" :run] +[1:57:54][@rygorous][@pervognsen Other things: 1. Bit-reversal shifters! 2. Funnel shifters!][:"logic design"] +[1:58:02][Funnel shifters][:"logic design" :speech] +[2:02:30][Introduce double_width_shifter() as a funnel shifter][:"logic design"] +[2:06:15][Define Example24 as a funnel shifter][:"logic design"] +[2:07:09][Instantiate a 16-bit funnel shifter and check out its graph, to see that it is off-by-one][:"debug visualisation" :"logic design" :run] +[2:10:21][Shrink the x input of our funnel shifter by one bit][:"logic design"] +[2:10:38][Check out our funnel shifter graph to see that it looks good][:"debug visualisation" :"logic design" :run] +[2:10:50][Rename double_width_shifter() to funnel_shifter()][:"logic design"] +[2:11:17][Create a test of our funnel shifter][:emulation :"logic design"] +[2:13:48][Simulate a 16-bit and 4-bit funnel shifter to see that it passes][:emulation :"logic design" :run] +[2:14:17][Introduce funnel_right_shifter()][:"logic design"] +[2:16:33][Simulate a funnel right shifter to see that it passes][:emulation :"logic design" :run] +[2:16:59][Introduce funnel_left_shifter()][:"logic design"] +[2:18:19][@rygorous][@pervognsen You need to be careful with the opposite-direction shifts later (so if you do a right shift funnel, look at the left shift)][:"logic design"] +[2:18:33][Simulate a funnel left shifter to see that it fails][:emulation :"logic design" :run] +[2:19:40][Fix funnel_left_shifter()][:"logic design"] +[2:20:06][Introduce funnel_arithmetic_right_shifter()][:"logic design"] +[2:21:44][Simulate the funnel arithmetic right shifter, fail the test and investigate why][:emulation :"logic design" :run] +[2:25:31][Make funnel_arithmetic_right_shifter() use rep()][:"logic design"] +[2:25:44][Simulate the funnel arithmetic right shifter and pass the test][:emulation :"logic design" :run] +[2:26:33][Introduce funnel_right_rotator()][:"logic design"] +[2:27:48][Simulate the funnel right rotator successfully][:emulation :"logic design" :run] +[2:27:54][Introduce funnel_left_rotator()][:"logic design"] +[2:28:35][Simulate the funnel left rotator and fail the test][:emulation :"logic design" :run] +[2:28:54][@rygorous][@pervognsen I think x\[1:\], but yeah][:"logic design"] +[2:29:03][Fix funnel_left_rotator() to slice off the correct bit][:"logic design"] +[2:29:09][Simulate the funnel left rotator successfully][:emulation :"logic design" :run] +[2:29:17][Introduce funnel_shifter_unit() as a combined design][:"logic design"] +[2:31:15][@rygorous][@pervognsen You probably want to cut the slices into three pieces: hi 31, middle, lo 31. That way each of the pieces needs fewer options (instead of having a big full-width mux)][:"logic design"] +[2:31:27][Q&A][:speech] +[2:32:09][@tw0st3p][Question for an after hours stream: Have you heard of Julia :language?] +[2:32:50][Try to time the :performance of our barrel shifter, modifying get_operator_delay() to handle the necessary operators][:profiling] +[2:34:38][Check out the delay of our barrel shifter][:"logic design" :performance :run] +[2:35:38][Call it a day][:speech] +[/video]