zlib: implement fast path for crc32

PR-URL: #59813 Reviewed-By: Michaël Zasso <[email protected]> Reviewed-By: Matteo Collina <[email protected]> Reviewed-By: Daniel Lemire <[email protected]> Reviewed-By: Trivikram Kamat <[email protected]> Reviewed-By: James M Snell <[email protected]> Reviewed-By: Ruben Bridgewater <[email protected]>

Author: gurgunday

benchmark/zlib/crc32.js

@@ -0,0 +1,47 @@
+'use strict';
+
+constcommon=require('../common.js');
+const{ crc32 }=require('zlib');
+
+// Benchmark crc32 on Buffer and String inputs across sizes.
+// Iteration count is scaled inversely with input length to keep runtime sane.
+// Example:
+// node benchmark/zlib/crc32.js type=buffer len=4096 n=4000000
+// ./out/Release/node benchmark/zlib/crc32.js --test
+
+constbench=common.createBenchmark(main,{
+type: ['buffer','string'],
+len: [32,256,4096,65536],
+n: [4e6],
+});
+
+functionmakeBuffer(size){
+constbuf=Buffer.allocUnsafe(size);
+for(leti=0;i<size;i++)buf[i]=(i*1103515245+12345)&0xff;
+returnbuf;
+}
+
+functionmakeAsciiString(size){
+constchars='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+letout='';
+for(leti=0,j=0;i<size;i++,j=(j+7)%chars.length)out+=chars[j];
+returnout;
+}
+
+functionmain({ type, len, n }){
+// Scale iterations so that total processed bytes roughly constant around n*4096 bytes.
+constscale=4096/len;
+constiters=Math.max(1,Math.floor(n*scale));
+
+constdata=type==='buffer' ? makeBuffer(len) : makeAsciiString(len);
+
+letacc=0;
+for(leti=0;i<Math.min(iters,10000);i++)acc^=crc32(data,0);
+
+bench.start();
+letsum=0;
+for(leti=0;i<iters;i++)sum^=crc32(data,0);
+bench.end(iters);
+
+if(sum===acc-1)process.stderr.write('');
+}

src/node_zlib.cc

@@ -30,6 +30,8 @@
 #include"threadpoolwork-inl.h"
 #include"util-inl.h"
 
+#include"node_debug.h"
+#include"v8-fast-api-calls.h"
 #include"v8.h"
 
 #include"brotli/decode.h"
@@ -48,6 +50,7 @@
 namespacenode{
 
 using v8::ArrayBuffer;
+using v8::CFunction;
 using v8::Context;
 using v8::Function;
 using v8::FunctionCallbackInfo;
@@ -1657,22 +1660,35 @@ T CallOnSequence(v8::Isolate* isolate, Local<Value> value, F callback){
  }
 }
 
-// TODO(joyeecheung): use fast API
+staticinlineuint32_tCRC32Impl(Isolate* isolate,
+ Local<Value> data,
+uint32_t value){
+return CallOnSequence<uint32_t>(
+ isolate, data, [&](constchar* ptr, size_t size) -> uint32_t{
+returnstatic_cast<uint32_t>(
+crc32(value, reinterpret_cast<const Bytef*>(ptr), size));
+ });
+}
+
 staticvoidCRC32(const FunctionCallbackInfo<Value>& args){
 CHECK(args[0]->IsArrayBufferView() || args[0]->IsString());
 CHECK(args[1]->IsUint32());
 uint32_t value = args[1].As<v8::Uint32>()->Value();
+ args.GetReturnValue().Set(CRC32Impl(args.GetIsolate(), args[0], value));
+}
 
-uint32_tresult = CallOnSequence<uint32_t>(
-args.GetIsolate(),
-args[0],
-[&](constchar* data, size_t size) -> uint32_t{
-returncrc32(value, reinterpret_cast<const Bytef*>(data), size);
- });
-
-args.GetReturnValue().Set(result);
+staticuint32_tFastCRC32(v8::Local<v8::Value> receiver,
+ v8::Local<v8::Value> data,
+uint32_t value,
+// NOLINTNEXTLINE(runtime/references)
+ v8::FastApiCallbackOptions& options){
+TRACK_V8_FAST_API_CALL("zlib.crc32");
+ v8::HandleScope handle_scope(options.isolate);
+returnCRC32Impl(options.isolate, data, value);
 }
 
+static CFunction fast_crc32_(CFunction::Make(FastCRC32));
+
 voidInitialize(Local<Object> target,
  Local<Value> unused,
  Local<Context> context,
@@ -1685,7 +1701,7 @@ void Initialize(Local<Object> target,
  MakeClass<ZstdCompressStream>::Make(env, target, "ZstdCompress");
  MakeClass<ZstdDecompressStream>::Make(env, target, "ZstdDecompress");
 
-SetMethod(context, target, "crc32", CRC32);
+SetFastMethodNoSideEffect(context, target, "crc32", CRC32, &fast_crc32_);
  target->Set(env->context(),
 FIXED_ONE_BYTE_STRING(env->isolate(), "ZLIB_VERSION"),
 FIXED_ONE_BYTE_STRING(env->isolate(), ZLIB_VERSION)).Check();
@@ -1698,6 +1714,7 @@ void RegisterExternalReferences(ExternalReferenceRegistry* registry){
  MakeClass<ZstdCompressStream>::Make(registry);
  MakeClass<ZstdDecompressStream>::Make(registry);
  registry->Register(CRC32);
+ registry->Register(fast_crc32_);
 }
 
 } // anonymous namespace

test/sequential/test-zlib-crc32-fast-api.js

@@ -0,0 +1,26 @@
+// Flags: --expose-internals --no-warnings --allow-natives-syntax
+'use strict';
+
+constcommon=require('../common');
+constassert=require('assert');
+constzlib=require('zlib');
+
+{
+functiontestFastPath(){
+constexpected=0xd87f7e0c;// zlib.crc32('test', 0)
+assert.strictEqual(zlib.crc32('test',0),expected);
+returnexpected;
+}
+
+eval('%PrepareFunctionForOptimization(zlib.crc32)');
+testFastPath();
+eval('%OptimizeFunctionOnNextCall(zlib.crc32)');
+testFastPath();
+testFastPath();
+
+if(common.isDebug){
+const{ internalBinding }=require('internal/test/binding');
+const{ getV8FastApiCallCount }=internalBinding('debug');
+assert.strictEqual(getV8FastApiCallCount('zlib.crc32'),2);
+}
+}