Apply non-branching logic to original WebGL pow shader.

Commit if statement replacement with select function, but do not replace all instances yet until mixing rounds are done being inlined.

Inline G mis 2 of round 1.

Inline G mix 1 of round 1.

Inline G mix 0 of round 1.

If reset is called, cpuBuffer is destroyed, so it does not make sense to then unmap it, so do that in the try block. Also try searching again after resetting.

Upload new bundle for testing.

Reset busy flag on device loss. Tighten try-catch block when getting results from GPU. Add reset function so it can be called automatically on device loss or manually on other errors.

Add error handling to test page. Upload new bundle for testing.

Implement busy flag to prevent concurrent initializations and searches. Rewrite init as async function. Explicitly destroy buffers if device is lost. Setup buffers and pipeline in separate function call. Refactor search into a while loop instead of recursive promises. Unmap CPU buffer as soon as possible. Do not retry search on caught error.

Lay out inlining to all remaining rounds. New code is still commented out, so original G function calls still function as before.

Add some whitespace to better delineate the start and end of the G mixing section.

Upload new bundle for testing.

Remove unused default exports that are now included in separate pow worker file.

Adjust error handling to try catching iOS error with more meaningful messaging.

Tweak layout of web page used for platform testing.

Save another benchmark with improved geometric mean and new best for minimum time at 21.6ms!

Improve geometric mean by using log approach.

Upload new bundle with inlined G round 0 for platform testing.

Benchmark a couple more times now that G round 0 is completely inlined.

Inline G mix 7 of round 0.

Inline G mix 6 of round 0.

Inline G mix 5 of round 0.

Add a little more whitespace for legibility.

Inline G mix 4 of round 0.

Restore 6-hash pow test to check different hashes still generate correct pow beyond single Nano test vector block.

Run a benchmark.

Inline G mix 3 of round 0.

Tweak comment.

Inline G mix 2 of round 0. Interestingly, we can skip some instructions this way due to addition of zero doing nothing to mix values, but the operation itself will be left visible for documentation and possible troubleshooting. Also note that pow values are verified working at this commit.

Adjust mix round subheading comments.

Expand documentation of implementation details.

Skip some pow perf tests while inlining G mix function.

Inline G mix 1 of round 0.

Adjust section headings.

Inline G mix 0 of round 0.

Start setting up inline of function call 0 of round 0.

Add sectional comments to clearly delineate G mix rounds as this moves into inlining the G mix function which will be otherwise difficult to read and navigate.

Remove comment relic.

Simplify imports with additional path mappings. Remove deprecated worker code from pow classes now that it is handled externally.

Overhaul project structure by separating NanoPow code from its worker interface, consolidating test and performance code into one directory, creating additional import path mappings, and renaming files in general.

Fix name references for pow objects.

Reorganize NanoPow into its own package.

Offload shader code to separate file.

Indicate units when bit shift constructing ID/

Upload new bundle for platform testing.

Implement device lost promise property to handle loss gracefully by reinitializing. Adjust try-catch error logging message and just retry search instead of reinitializing class.

Upload new bundle for platform testing.

Fix class reference used for static members within static context when this should be used. Small change to initialization so class can be reloaded if necessary. Implement try-catch if getting data from GPU throws so we can reinitialize.

Fix test page header.

Upload new bundle for platform testing.

Fix block perf test suite messages.

Extend time interval between check for GPU device to save mobile device cycles.

Couple more benchmarks.

Throttle back workgroup size since apparently this value works with GPUs better and we're still checking over a billion nonces per dispatch; the probability of finding a nonce at this level is over 99.9%

Refactor GPU device loading to avoid high promise stack.

Switch block back to PowGpu.

Set up canvas size for proper pow comparison testing.

Restore all block performance tests. Fix PowGl execution.

Merge redundant find function with calculate to form search function like PowGpu. Implement more of a promise-based pipeline through PowGl calculations.

Inline G mix function addition steps to eliminate a function call.

Log some more benchmarks. Switch back to PowGl for blocks, with the plan to later make PowGpu available behind a flag.

Get rid of extraneous logging in PowGl.

Rename and export PowGl for systems that don't support WebGPU. Update some other names.

Avoid loading nano-webgl-pow entirely. Upload bundle for platform testing.

Remove final unused v array pointer.

Replace v[d] indexes with pointers.

Replace v[c] indexes with pointers.

Replace v[b] indexes with pointers.

Remove replaced v[a] arguments.

Remove v array now that individual variables have been confirmed.

Try updating G mix function again; rounds need to be updated next.

Revert array pointer dereferencing to troubleshoot invalid nonces.

Revert some pointer implementations due to incorrect nonces now.

Fix variable name.

Refactor returned promises.

notes

Fix this later.

Throw more specific error during search call. Revert workload again since research is saying mobile devices should be able to handle workgroups of 256.

Upload bundle for platform testing.

Set workload dynamically based on hardware.

Eliminate redundant find function. Rename #calculate to search in order to both better represent its purpose as well as work around Safari limitation on private class methods.

Note long benchmark run.

Skip nano-webgl-pow test comparison for now.

Upload bundle for testing.

Convert first of four v accessors to pointer references.

Benchmark min and max times, and add another round of testing.

Move benchmarks notes and add new timings.

Wait a maximum of 8 seconds to load GPU.

Remove outdated documentation comment.

Eliminate m array. Fix nonce construction.

Pass literal zeros since these array indexes are never initialized.

Yep, it was an issue.

Delete unused parameter.

Update G mix rounds 6-11.

Update G mix round 5 (round 4 was done in previous commit).

Document odd difference between blake C reference implementation and nano-webgl-pow port that might need fixing later.

Update G mix round 3.

Update G mix round 2.

Intermediate update to convert m array lookups to variables. Remaining 10 rounds of G mixing must be converted still.