Class: VibeZstd::CCtx

Inherits:
Object
  • Object
show all
Defined in:
ext/vibe_zstd/vibe_zstd.c

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.estimate_memory(level) ⇒ Object

CCtx.estimate_memory(level)



37
38
39
40
41
42
 
# File 'ext/vibe_zstd/cctx.c', line 37

static VALUE
vibe_zstd_cctx_estimate_memory(VALUE self, VALUE level) {
    int lvl = NUM2INT(level);
    size_t estimate = ZSTD_estimateCCtxSize(lvl);
    return SIZET2NUM(estimate);
}

.parameter_bounds ⇒ Object

Instance Method Details

#block_delimiters ⇒ Object Also known as: block_delimiters?

#block_delimiters= ⇒ Object

#chain_log ⇒ Object

#chain_log= ⇒ Object

#checksum_flag ⇒ Object Also known as: checksum, checksum?

#checksum_flag= ⇒ Object Also known as: checksum=

#compress(*args) ⇒ Object

Releases GVL during compression to allow other Ruby threads to run.



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
 
# File 'ext/vibe_zstd/cctx.c', line 83

static VALUE
vibe_zstd_cctx_compress(int argc, VALUE* argv, VALUE self) {
    VALUE data, options = Qnil;
    rb_scan_args(argc, argv, "1:", &data, &options);
    vibe_zstd_cctx* cctx;
    TypedData_Get_Struct(self, vibe_zstd_cctx, &vibe_zstd_cctx_type, cctx);
    StringValue(data);

    // Extract keyword arguments
    int lvl = ZSTD_defaultCLevel();
    ZSTD_CDict* cdict = NULL;
    unsigned long long pledged_size = ZSTD_CONTENTSIZE_UNKNOWN;

    if (!NIL_P(options)) {
        // Handle level keyword argument
        VALUE level_val = rb_hash_aref(options, ID2SYM(rb_intern("level")));
        if (!NIL_P(level_val)) {
            lvl = NUM2INT(level_val);
        }

        // Handle dict keyword argument
        VALUE dict_val = rb_hash_aref(options, ID2SYM(rb_intern("dict")));
        if (!NIL_P(dict_val)) {
            vibe_zstd_cdict* cdict_struct;
            TypedData_Get_Struct(dict_val, vibe_zstd_cdict, &vibe_zstd_cdict_type, cdict_struct);
            cdict = cdict_struct->cdict;
        }

        // Handle pledged_size keyword argument
        VALUE pledged_size_val = rb_hash_aref(options, ID2SYM(rb_intern("pledged_size")));
        if (!NIL_P(pledged_size_val)) {
            pledged_size = NUM2ULL(pledged_size_val);
        }
    }

    // Set pledged size if provided
    if (pledged_size != ZSTD_CONTENTSIZE_UNKNOWN) {
        size_t result = ZSTD_CCtx_setPledgedSrcSize(cctx->cctx, pledged_size);
        if (ZSTD_isError(result)) {
            rb_raise(rb_eRuntimeError, "Failed to set pledged_size %llu: %s", pledged_size, ZSTD_getErrorName(result));
        }
    }

    size_t srcSize = RSTRING_LEN(data);
    size_t dstCapacity = ZSTD_compressBound(srcSize);
    VALUE result_str = rb_str_new(NULL, dstCapacity);
    compress_args args = {
        .cctx = cctx->cctx,
        .cdict = cdict,
        .src = RSTRING_PTR(data),
        .srcSize = srcSize,
        .dst = RSTRING_PTR(result_str),
        .dstCapacity = dstCapacity,
        .compressionLevel = lvl,
        .result = 0
    };
    rb_thread_call_without_gvl(compress_without_gvl, &args, NULL, NULL);
    if (ZSTD_isError(args.result)) {
        rb_raise(rb_eRuntimeError, "Compression failed: %s", ZSTD_getErrorName(args.result));
    }
    rb_str_set_len(result_str, args.result);
    return result_str;
}

#compression_level ⇒ Object Also known as: level

#compression_level= ⇒ Object Also known as: level=

CCtx parameter accessors

#content_size_flag ⇒ Object Also known as: content_size, content_size?

#content_size_flag= ⇒ Object Also known as: content_size=

#deterministic_ref_prefix ⇒ Object Also known as: deterministic_ref_prefix?

#deterministic_ref_prefix= ⇒ Object

#dict_id_flag ⇒ Object Also known as: dict_id, dict_id?

#dict_id_flag= ⇒ Object Also known as: dict_id=

#enable_dedicated_dict_search ⇒ Object Also known as: enable_dedicated_dict_search?

#enable_dedicated_dict_search= ⇒ Object

#enable_long_distance_matching ⇒ Object Also known as: long_distance_matching, long_distance_matching?

#enable_long_distance_matching= ⇒ Object Also known as: long_distance_matching=

#enable_seq_producer_fallback ⇒ Object Also known as: enable_seq_producer_fallback?

#enable_seq_producer_fallback= ⇒ Object

#force_attach_dict ⇒ Object

#force_attach_dict= ⇒ Object

#force_max_window ⇒ Object Also known as: force_max_window?

#force_max_window= ⇒ Object

#format ⇒ Object

#format= ⇒ Object

#hash_log ⇒ Object

#hash_log= ⇒ Object

#job_size ⇒ Object

#job_size= ⇒ Object

#ldm_bucket_size_log ⇒ Object

#ldm_bucket_size_log= ⇒ Object

#ldm_hash_log ⇒ Object

#ldm_hash_log= ⇒ Object

#ldm_hash_rate_log ⇒ Object

#ldm_hash_rate_log= ⇒ Object

#ldm_min_match ⇒ Object

#ldm_min_match= ⇒ Object

#literal_compression_mode ⇒ Object

#literal_compression_mode= ⇒ Object

#max_block_size ⇒ Object

#max_block_size= ⇒ Object

#min_match ⇒ Object

#min_match= ⇒ Object

#overlap_log ⇒ Object

#overlap_log= ⇒ Object

#prefetch_cdict_tables ⇒ Object

#prefetch_cdict_tables= ⇒ Object

#reset(*args) ⇒ Object

CCtx reset - reset context to clean state



417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
 
# File 'ext/vibe_zstd/cctx.c', line 417

static VALUE
vibe_zstd_cctx_reset(int argc, VALUE* argv, VALUE self) {
    VALUE reset_mode;
    rb_scan_args(argc, argv, "01", &reset_mode);

    vibe_zstd_cctx* cctx;
    TypedData_Get_Struct(self, vibe_zstd_cctx, &vibe_zstd_cctx_type, cctx);

    // Default to SESSION_AND_PARAMETERS if no argument provided
    ZSTD_ResetDirective directive = ZSTD_reset_session_and_parameters;

    if (!NIL_P(reset_mode)) {
        int mode = NUM2INT(reset_mode);
        if (mode == ZSTD_reset_session_only) {
            directive = ZSTD_reset_session_only;
        } else if (mode == ZSTD_reset_parameters) {
            directive = ZSTD_reset_parameters;
        } else if (mode == ZSTD_reset_session_and_parameters) {
            directive = ZSTD_reset_session_and_parameters;
        } else {
            rb_raise(rb_eArgError, "Invalid reset_mode %d: must be ResetDirective::SESSION (1), PARAMETERS (2), or BOTH (3)", mode);
        }
    }

    size_t result = ZSTD_CCtx_reset(cctx->cctx, directive);

    if (ZSTD_isError(result)) {
        rb_raise(rb_eRuntimeError, "Failed to reset compression context: %s", ZSTD_getErrorName(result));
    }

    return self;
}

#rsyncable ⇒ Object Also known as: rsyncable?

#rsyncable= ⇒ Object

#search_for_external_repcodes ⇒ Object

#search_for_external_repcodes= ⇒ Object

#search_log ⇒ Object

#search_log= ⇒ Object

#src_size_hint ⇒ Object

#src_size_hint= ⇒ Object

#stable_in_buffer ⇒ Object Also known as: stable_in_buffer?

#stable_in_buffer= ⇒ Object

#stable_out_buffer ⇒ Object Also known as: stable_out_buffer?

#stable_out_buffer= ⇒ Object

#strategy ⇒ Object

#strategy= ⇒ Object

#target_cblock_size ⇒ Object

#target_cblock_size= ⇒ Object

#target_length ⇒ Object

#target_length= ⇒ Object

#use_prefix(prefix_data) ⇒ Object

CCtx use_prefix - use raw data as prefix (lightweight dictionary)



400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
 
# File 'ext/vibe_zstd/cctx.c', line 400

static VALUE
vibe_zstd_cctx_use_prefix(VALUE self, VALUE prefix_data) {
    vibe_zstd_cctx* cctx;
    TypedData_Get_Struct(self, vibe_zstd_cctx, &vibe_zstd_cctx_type, cctx);

    StringValue(prefix_data);

    size_t result = ZSTD_CCtx_refPrefix(cctx->cctx, RSTRING_PTR(prefix_data), RSTRING_LEN(prefix_data));

    if (ZSTD_isError(result)) {
        rb_raise(rb_eRuntimeError, "Failed to set prefix: %s", ZSTD_getErrorName(result));
    }

    return self;
}

#use_row_match_finder ⇒ Object

#use_row_match_finder= ⇒ Object

#validate_sequences ⇒ Object Also known as: validate_sequences?

#validate_sequences= ⇒ Object

#window_log ⇒ Object

#window_log= ⇒ Object

#workers ⇒ Object

#workers= ⇒ Object