From 0b0bcb3657ed709f23d49df919869ea71698b0b3 Mon Sep 17 00:00:00 2001 From: Matt Mascarenhas Date: Fri, 20 Jul 2018 17:26:10 +0100 Subject: [PATCH] Annotate bitwise050 --- pervognsen/bitwise/bitwise/bitwise050.hmml | 78 ++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 pervognsen/bitwise/bitwise/bitwise050.hmml diff --git a/pervognsen/bitwise/bitwise/bitwise050.hmml b/pervognsen/bitwise/bitwise/bitwise050.hmml new file mode 100644 index 0000000..316d549 --- /dev/null +++ b/pervognsen/bitwise/bitwise/bitwise050.hmml @@ -0,0 +1,78 @@ +[video member=pervognsen stream_platform=twitch project=bitwise title="Logic Design, Part 2" vod_platform=youtube id=HGZzNAxf3sg annotator=Miblo] +[0:07][Set the stage for the day continuing on :"logic design"][:speech] +[0:25][Review the notion of boolean logic expressions, and turning a truth table into a sum of products representation][:"logic design" :research] +[2:06][Review our ability to tabulate functions to their truth table][:"logic design" :research] +[3:23][Demo function_to_sum_of_products() on an OR function][:"logic design"] +[4:00][:Run it to see our non-minimal representation of OR, noting that the problem of producing the minimal representation in the general case is NP-complete[ref + site=Wikipedia + page="Karnaugh map" + url=https://en.wikipedia.org/wiki/Karnaugh_map][ref + site=Wikipedia + page="Quine–McCluskey algorithm" + url=https://en.wikipedia.org/wiki/Quine%E2%80%93McCluskey_algorithm][ref + site=Wikipedia + page="Espresso heuristic logic minimizer" + url=https://en.wikipedia.org/wiki/Espresso_heuristic_logic_minimizer]][:"debug visualisation" :"logic design" :optimisation] +[7:10][Review off-stream change to using a bit vector for the input][:"logic design" :research] +[7:46][Review muxes and Shannon expansion][:"logic design" :research] +[8:35][Consult the graph for our Example3 parity function, highlighting the shareable nodes and bit vector notation, and noting the usefulness of binary decision diagrams][:"debug visualisation" :"logic design" :run] +[12:33][Note the efficiency of muxes for XOR implementations][:"debug visualisation" :"logic design" :run] +[13:04][Understanding XOR as a conditional inverter][:"logic design" :speech] +[14:45][Define Example4 as a 5-bit XOR reduction circuit][:"logic design"] +[15:33][Check out our 5-bit XOR reduced graph, noting its linear depth][:"debug visualisation" :"logic design" :run] +[16:03][Introduce reduce() to illustrate linear reduction][:"logic design"] +[18:13][:Run it to see that the graph is the same as before][:"debug visualisation" :"logic design" :run] +[18:42][Rename reduce() to linear_reduce() and introduce logarithmic_reduce() as a divide and conquer reduction][:"logic design"] +[22:16][:Run it to see that it works but is slightly unbalanced for a non-power of two][:"debug visualisation" :"logic design"] +[22:36][:Run it on an 8-bit input, to see that our graph is fully balanced][:"debug visualisation" :"logic design"] +[25:21][A few words on divide and conquer and the fork–join model[ref + site=Wikipedia + page="Fork–join model" + url=https://en.wikipedia.org/wiki/Fork%E2%80%93join_model]][:optimisation :speech] +[26:13][Determine to cover standard circuit elements and write a simulator][:"logic design" :emulation :speech] +[27:07][Define Example5 as an 8-bit comparison function, applying reduction][:"logic design"] +[30:38][Check out the graph of our 8-bit comparison function][:"debug visualisation" :"logic design" :run] +[32:19][Q&A][:speech] +[32:38][@rygorous][Good thing CPUs don't have silly shit like, say, a "parity" flag bit that is set to match the parity of the last 64-bit result you computed][:"logic design"] +[33:06][Define Example6 as an 8-bit comparison function in which one of the values is constant][:"logic design"] +[34:38][Check out our graphed comparison against a constant][:"debug visualisation" :"logic design" :run] +[35:23][Introduce equals_constant() as a bespoke constant comparer][:"logic design" :optimisation] +[37:51][Check out our more optimal constant comparison graph][:"debug visualisation" :"logic design" :optimisation :run] +[39:23][Ripple-carry adder][:"logic design" :speech] +[43:33][Sketch out add3()][:"logic design" :speech] +[46:17][Introduce add() as bit-vector adder using our sketched out add3()][:"logic design"] +[48:15][Define Example7 as a 4-bit ripple-carry adder][:"logic design"] +[49:21][:Run it to see that the graph is already too much][:"debug visualisation" :"logic design"] +[49:29][Change Example7 from a 4- to 2-bit ripple-carry adder][:"logic design"] +[49:56][:Run it to see our 2-bit ripple-carry adder][:"debug visualisation" :"logic design"] +[50:56][Create Add3 module][:"logic design"] +[52:47][Check out our 2-bit ripple-carry adder to see more clearly the chain structure of the Add3 modules][:"debug visualisation" :"logic design" :run] +[53:12][Check out our 4-bit ripple-carry adder, noting that we likely wouldn't make an adder manually for our FPGA, letting our logic synthesis tools pick which adder to instantiate][:"debug visualisation" :"logic design" :run] +[54:43][@barely_polar][Does this add work with negatives?][:"logic design"] +[54:49][@rygorous][In two's complement, yes][:"logic design"] +[56:11][Prevent add() from taking the carry][:"logic design"] +[56:52][Check out our ripple-carry adder with only internal carries][:"debug visualisation" :"logic design" :optimisation :run] +[57:15][Consider simplifications to Add3 when the carry is 0, to make a half-adder][:"logic design" :optimisation :speech] +[1:01:12][Split out the intermediate propagating and generated carry bits in Add3][:"logic design"] +[1:02:38][Check out the graph of our Add3 half-adder module][:"debug visualisation" :"logic design" :run] +[1:04:25][Subtraction in two's complement][:"logic design" :speech] +[1:06:31][Introduce sub() using add(), also having changed add() back to take a carry][:"logic design"] +[1:07:30][Check out our subtraction graph][:"debug visualisation" :"logic design" :run] +[1:07:44][Define Example9 as a simple ALU that does addition or subtraction depending on the state of an operation bit][:"logic design"] +[1:10:17][Check out our addition / subtraction ALU][:"debug visualisation" :"logic design" :run] +[1:11:48][@barely_polar][Can you talk about the intuition for why flipping the bits and adding 1 is equivalent to subtraction? I can see it's true but don't understand why][:"logic design"] +[1:14:21][Equality comparison][:"logic design" :speech] +[1:15:18][Lexicographical equality comparison][:"logic design" :speech] +[1:18:25][Subtraction and < 0 equality comparison in an ALU][:"logic design" :speech] +[1:19:53][Change add() to output the carry][:"logic design"] +[1:21:06][Create Example10 module as a subtraction and < 0 comparator][:"logic design"] +[1:21:58][Check out our comparison graph][:"debug visualisation" :"logic design" :run] +[1:22:46][Explicit zero-extension in lieu of the output carry][:"logic design" :speech] +[1:24:59][Check our workings with [@rygorous Fabian]][:"logic design" :speech] +[1:25:30][@rygorous][@pervognsen Not actually sure][:"logic design"] +[1:26:17][Create Example11 module as a signed comparator][:"logic design"] +[1:26:41][Check out our signed comparator graph][:"debug visualisation" :"logic design" :run] +[1:26:47][@rygorous][@pervognsen I just know the normal form which uses N and V bits][:"logic design"] +[1:28:01][Reflect on our comparator modules, noting that you cannot overflow when extending by one bit][:"logic design" :speech] +[1:31:00][That's a good stopping point][:speech] +[/video]