Ruby 4.0.10p0 (2026-11-19 revision a704b7cd95a42cc0cf5f307137bf3aac0285b915)
memory_view.c
1/**********************************************************************
2
3 memory_view.c - Memory View
4
5 Copyright (C) 2020 Kenta Murata <mrkn@mrkn.jp>
6
7**********************************************************************/
8
9#include "internal.h"
10#include "internal/hash.h"
11#include "internal/variable.h"
12#include "ruby/memory_view.h"
13#include "ruby/util.h"
14#include "vm_sync.h"
15
16#if SIZEOF_INTPTR_T == SIZEOF_LONG_LONG
17# define INTPTR2NUM LL2NUM
18# define UINTPTR2NUM ULL2NUM
19#elif SIZEOF_INTPTR_T == SIZEOF_LONG
20# define INTPTR2NUM LONG2NUM
21# define UINTPTR2NUM ULONG2NUM
22#else
23# define INTPTR2NUM INT2NUM
24# define UINTPTR2NUM UINT2NUM
25#endif
26
27
28#define STRUCT_ALIGNOF(T, result) do { \
29 (result) = RUBY_ALIGNOF(T); \
30} while(0)
31
32// Exported Object Registry
33
34static st_table *exported_object_table = NULL;
35VALUE rb_memory_view_exported_object_registry = Qundef;
36
37static int
38exported_object_registry_mark_key_i(st_data_t key, st_data_t value, st_data_t data)
39{
40 rb_gc_mark(key);
41 return ST_CONTINUE;
42}
43
44static void
45exported_object_registry_mark(void *ptr)
46{
47 // Don't use RB_VM_LOCK_ENTER here. It is unnecessary during GC.
48 st_foreach(exported_object_table, exported_object_registry_mark_key_i, 0);
49}
50
51static void
52exported_object_registry_free(void *ptr)
53{
54 RB_VM_LOCKING() {
55 st_clear(exported_object_table);
56 st_free_table(exported_object_table);
57 exported_object_table = NULL;
58 }
59}
60
61const rb_data_type_t rb_memory_view_exported_object_registry_data_type = {
62 "memory_view/exported_object_registry",
63 {
64 exported_object_registry_mark,
65 exported_object_registry_free,
66 0,
67 },
68 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
69};
70
71static int
72exported_object_add_ref(st_data_t *key, st_data_t *val, st_data_t arg, int existing)
73{
74 ASSERT_vm_locking();
75
76 if (existing) {
77 *val += 1;
78 }
79 else {
80 *val = 1;
81 }
82 return ST_CONTINUE;
83}
84
85static int
86exported_object_dec_ref(st_data_t *key, st_data_t *val, st_data_t arg, int existing)
87{
88 ASSERT_vm_locking();
89
90 if (existing) {
91 *val -= 1;
92 if (*val == 0) {
93 return ST_DELETE;
94 }
95 }
96 return ST_CONTINUE;
97}
98
99static void
100register_exported_object(VALUE obj)
101{
102 RB_VM_LOCKING() {
103 st_update(exported_object_table, (st_data_t)obj, exported_object_add_ref, 0);
104 }
105}
106
107static void
108unregister_exported_object(VALUE obj)
109{
110 RB_VM_LOCKING() {
111 if (exported_object_table)
112 st_update(exported_object_table, (st_data_t)obj, exported_object_dec_ref, 0);
113 }
114}
115
116// MemoryView
117
118static ID id_memory_view;
119
120static const rb_data_type_t memory_view_entry_data_type = {
121 "memory_view/entry",
122 {
123 0,
124 0,
125 0,
126 },
127 0, 0, RUBY_TYPED_FREE_IMMEDIATELY
128};
129
130/* Register memory view functions for the given class */
131bool
133{
134 Check_Type(klass, T_CLASS);
135 VALUE entry_obj = rb_ivar_lookup(klass, id_memory_view, Qnil);
136 if (! NIL_P(entry_obj)) {
137 rb_warning("Duplicated registration of memory view to %"PRIsVALUE, klass);
138 return false;
139 }
140 else {
141 entry_obj = TypedData_Wrap_Struct(0, &memory_view_entry_data_type, (void *)entry);
142 rb_ivar_set(klass, id_memory_view, entry_obj);
143 return true;
144 }
145}
146
147/* Examine whether the given memory view has row-major order strides. */
148bool
150{
151 const ssize_t ndim = view->ndim;
152 const ssize_t *shape = view->shape;
153 const ssize_t *strides = view->strides;
154 ssize_t n = view->item_size;
155 ssize_t i;
156 for (i = ndim - 1; i >= 0; --i) {
157 if (strides[i] != n) return false;
158 n *= shape[i];
159 }
160 return true;
161}
162
163/* Examine whether the given memory view has column-major order strides. */
164bool
166{
167 const ssize_t ndim = view->ndim;
168 const ssize_t *shape = view->shape;
169 const ssize_t *strides = view->strides;
170 ssize_t n = view->item_size;
171 ssize_t i;
172 for (i = 0; i < ndim; ++i) {
173 if (strides[i] != n) return false;
174 n *= shape[i];
175 }
176 return true;
177}
178
179/* Initialize strides array to represent the specified contiguous array. */
180void
181rb_memory_view_fill_contiguous_strides(const ssize_t ndim, const ssize_t item_size, const ssize_t *const shape, const bool row_major_p, ssize_t *const strides)
182{
183 ssize_t i, n = item_size;
184 if (row_major_p) {
185 for (i = ndim - 1; i >= 0; --i) {
186 strides[i] = n;
187 n *= shape[i];
188 }
189 }
190 else { // column-major
191 for (i = 0; i < ndim; ++i) {
192 strides[i] = n;
193 n *= shape[i];
194 }
195 }
196}
197
198/* Initialize view to expose a simple byte array */
199bool
200rb_memory_view_init_as_byte_array(rb_memory_view_t *view, VALUE obj, void *data, const ssize_t len, const bool readonly)
201{
202 view->obj = obj;
203 view->data = data;
204 view->byte_size = len;
205 view->readonly = readonly;
206 view->format = NULL;
207 view->item_size = 1;
208 view->item_desc.components = NULL;
209 view->item_desc.length = 0;
210 view->ndim = 1;
211 view->shape = NULL;
212 view->strides = NULL;
213 view->sub_offsets = NULL;
214 view->private_data = NULL;
215
216 return true;
217}
218
219#ifdef HAVE_TRUE_LONG_LONG
220static const char native_types[] = "sSiIlLqQjJ";
221#else
222static const char native_types[] = "sSiIlLjJ";
223#endif
224static const char endianness_types[] = "sSiIlLqQjJ";
225
226typedef enum {
227 ENDIANNESS_NATIVE,
228 ENDIANNESS_LITTLE,
229 ENDIANNESS_BIG
230} endianness_t;
231
232static ssize_t
233get_format_size(const char *format, bool *native_p, ssize_t *alignment, endianness_t *endianness, ssize_t *count, const char **next_format, VALUE *error)
234{
235 RUBY_ASSERT(format != NULL);
236 RUBY_ASSERT(native_p != NULL);
237 RUBY_ASSERT(endianness != NULL);
238 RUBY_ASSERT(count != NULL);
239 RUBY_ASSERT(next_format != NULL);
240
241 *native_p = false;
242 *endianness = ENDIANNESS_NATIVE;
243 *count = 1;
244
245 const int type_char = *format;
246
247 int i = 1;
248 while (format[i]) {
249 switch (format[i]) {
250 case '!':
251 case '_':
252 if (strchr(native_types, type_char)) {
253 *native_p = true;
254 ++i;
255 }
256 else {
257 if (error) {
258 *error = rb_exc_new_str(rb_eArgError,
259 rb_sprintf("Unable to specify native size for '%c'", type_char));
260 }
261 return -1;
262 }
263 continue;
264
265 case '<':
266 case '>':
267 if (!strchr(endianness_types, type_char)) {
268 if (error) {
269 *error = rb_exc_new_str(rb_eArgError,
270 rb_sprintf("Unable to specify endianness for '%c'", type_char));
271 }
272 return -1;
273 }
274 if (*endianness != ENDIANNESS_NATIVE) {
275 *error = rb_exc_new_cstr(rb_eArgError, "Unable to use both '<' and '>' multiple times");
276 return -1;
277 }
278 *endianness = (format[i] == '<') ? ENDIANNESS_LITTLE : ENDIANNESS_BIG;
279 ++i;
280 continue;
281
282 default:
283 break;
284 }
285
286 break;
287 }
288
289 // parse count
290 int ch = format[i];
291 if ('0' <= ch && ch <= '9') {
292 ssize_t n = 0;
293 while ('0' <= (ch = format[i]) && ch <= '9') {
294 n = 10*n + ruby_digit36_to_number_table[ch];
295 ++i;
296 }
297 *count = n;
298 }
299
300 *next_format = &format[i];
301
302 switch (type_char) {
303 case 'x': // padding
304 return 1;
305
306 case 'c': // signed char
307 case 'C': // unsigned char
308 return sizeof(char);
309
310 case 's': // s for int16_t, s! for signed short
311 case 'S': // S for uint16_t, S! for unsigned short
312 if (*native_p) {
313 STRUCT_ALIGNOF(short, *alignment);
314 return sizeof(short);
315 }
316 // fall through
317
318 case 'n': // n for big-endian 16bit unsigned integer
319 case 'v': // v for little-endian 16bit unsigned integer
320 STRUCT_ALIGNOF(int16_t, *alignment);
321 return 2;
322
323 case 'i': // i and i! for signed int
324 case 'I': // I and I! for unsigned int
325 STRUCT_ALIGNOF(int, *alignment);
326 return sizeof(int);
327
328 case 'l': // l for int32_t, l! for signed long
329 case 'L': // L for uint32_t, L! for unsigned long
330 if (*native_p) {
331 STRUCT_ALIGNOF(long, *alignment);
332 return sizeof(long);
333 }
334 // fall through
335
336 case 'N': // N for big-endian 32bit unsigned integer
337 case 'V': // V for little-endian 32bit unsigned integer
338 STRUCT_ALIGNOF(int32_t, *alignment);
339 return 4;
340
341 case 'f': // f for native float
342 case 'e': // e for little-endian float
343 case 'g': // g for big-endian float
344 STRUCT_ALIGNOF(float, *alignment);
345 return sizeof(float);
346
347 case 'q': // q for int64_t, q! for signed long long
348 case 'Q': // Q for uint64_t, Q! for unsigned long long
349 if (*native_p) {
350 STRUCT_ALIGNOF(LONG_LONG, *alignment);
351 return sizeof(LONG_LONG);
352 }
353 STRUCT_ALIGNOF(int64_t, *alignment);
354 return 8;
355
356 case 'd': // d for native double
357 case 'E': // E for little-endian double
358 case 'G': // G for big-endian double
359 STRUCT_ALIGNOF(double, *alignment);
360 return sizeof(double);
361
362 case 'j': // j for intptr_t
363 case 'J': // J for uintptr_t
364 STRUCT_ALIGNOF(intptr_t, *alignment);
365 return sizeof(intptr_t);
366
367 default:
368 *alignment = -1;
369 if (error) {
370 *error = rb_exc_new_str(rb_eArgError, rb_sprintf("Invalid type character '%c'", type_char));
371 }
372 return -1;
373 }
374}
375
376static inline ssize_t
377calculate_padding(ssize_t total, ssize_t alignment_size)
378{
379 if (alignment_size > 1) {
380 ssize_t res = total % alignment_size;
381 if (res > 0) {
382 return alignment_size - res;
383 }
384 }
385 return 0;
386}
387
388ssize_t
391 size_t *n_members, const char **err)
392{
393 if (format == NULL) return 1;
394
395 VALUE error = Qnil;
396 ssize_t total = 0;
397 size_t len = 0;
398 bool alignment = false;
399 ssize_t max_alignment_size = 0;
400
401 const char *p = format;
402 if (*p == '|') { // alignment specifier
403 alignment = true;
404 ++format;
405 ++p;
406 }
407 while (*p) {
408 const char *q = p;
409
410 // ignore spaces
411 if (ISSPACE(*p)) {
412 while (ISSPACE(*p)) ++p;
413 continue;
414 }
415
416 bool native_size_p = false;
417 ssize_t alignment_size = 0;
418 endianness_t endianness = ENDIANNESS_NATIVE;
419 ssize_t count = 0;
420 const ssize_t size = get_format_size(p, &native_size_p, &alignment_size, &endianness, &count, &p, &error);
421 if (size < 0) {
422 if (err) *err = q;
423 return -1;
424 }
425 if (max_alignment_size < alignment_size) {
426 max_alignment_size = alignment_size;
427 }
428
429 const ssize_t padding = alignment ? calculate_padding(total, alignment_size) : 0;
430 total += padding + size * count;
431
432 if (*q != 'x') {
433 ++len;
434 }
435 }
436
437 // adjust total size with the alignment size of the largest element
438 if (alignment && max_alignment_size > 0) {
439 const ssize_t padding = calculate_padding(total, max_alignment_size);
440 total += padding;
441 }
442
443 if (members && n_members) {
445
446 ssize_t i = 0, offset = 0;
447 const char *p = format;
448 while (*p) {
449 // ignore spaces
450 if (ISSPACE(*p)) {
451 while (ISSPACE(*p)) ++p;
452 continue;
453 }
454
455 const int type_char = *p;
456
457 bool native_size_p;
458 ssize_t alignment_size = 0;
459 endianness_t endianness = ENDIANNESS_NATIVE;
460 ssize_t count = 0;
461 const ssize_t size = get_format_size(p, &native_size_p, &alignment_size, &endianness, &count, &p, NULL);
462
463 const ssize_t padding = alignment ? calculate_padding(offset, alignment_size) : 0;
464 offset += padding;
465
466 if (type_char != 'x') {
467#ifdef WORDS_BIGENDIAN
468 bool little_endian_p = (endianness == ENDIANNESS_LITTLE);
469#else
470 bool little_endian_p = (endianness != ENDIANNESS_BIG);
471#endif
472
473 switch (type_char) {
474 case 'e':
475 case 'E':
476 case 'v':
477 case 'V':
478 little_endian_p = true;
479 break;
480 case 'g':
481 case 'G':
482 case 'n':
483 case 'N':
484 little_endian_p = false;
485 break;
486 default:
487 break;
488 }
489
491 .format = type_char,
492 .native_size_p = native_size_p,
493 .little_endian_p = little_endian_p,
494 .offset = offset,
495 .size = size,
496 .repeat = count
497 };
498 }
499
500 offset += size * count;
501 }
502
503 *members = buf;
504 *n_members = len;
505 }
506
507 return total;
508}
509
510/* Return the item size. */
511ssize_t
512rb_memory_view_item_size_from_format(const char *format, const char **err)
513{
514 return rb_memory_view_parse_item_format(format, NULL, NULL, err);
515}
516
517/* Return the pointer to the item located by the given indices. */
518void *
520{
521 uint8_t *ptr = view->data;
522
523 if (view->ndim == 1) {
524 ssize_t stride = view->strides != NULL ? view->strides[0] : view->item_size;
525 return ptr + indices[0] * stride;
526 }
527
528 assert(view->shape != NULL);
529
530 ssize_t i;
531 if (view->strides == NULL) {
532 // row-major contiguous array
533 ssize_t stride = view->item_size;
534 for (i = 0; i < view->ndim; ++i) {
535 stride *= view->shape[i];
536 }
537 for (i = 0; i < view->ndim; ++i) {
538 stride /= view->shape[i];
539 ptr += indices[i] * stride;
540 }
541 }
542 else if (view->sub_offsets == NULL) {
543 // flat strided array
544 for (i = 0; i < view->ndim; ++i) {
545 ptr += indices[i] * view->strides[i];
546 }
547 }
548 else {
549 // indirect strided array
550 for (i = 0; i < view->ndim; ++i) {
551 ptr += indices[i] * view->strides[i];
552 if (view->sub_offsets[i] >= 0) {
553 ptr = *(uint8_t **)ptr + view->sub_offsets[i];
554 }
555 }
556 }
557
558 return ptr;
559}
560
561static void
562switch_endianness(uint8_t *buf, ssize_t len)
563{
564 RUBY_ASSERT(buf != NULL);
565 RUBY_ASSERT(len >= 0);
566
567 uint8_t *p = buf;
568 uint8_t *q = buf + len - 1;
569
570 while (q - p > 0) {
571 uint8_t t = *p;
572 *p = *q;
573 *q = t;
574 ++p;
575 --q;
576 }
577}
578
579static inline VALUE
580extract_item_member(const uint8_t *ptr, const rb_memory_view_item_component_t *member, const size_t i)
581{
582 RUBY_ASSERT(ptr != NULL);
583 RUBY_ASSERT(member != NULL);
584 RUBY_ASSERT(i < member->repeat);
585
586#ifdef WORDS_BIGENDIAN
587 const bool native_endian_p = !member->little_endian_p;
588#else
589 const bool native_endian_p = member->little_endian_p;
590#endif
591
592 const uint8_t *p = ptr + member->offset + i * member->size;
593
594 if (member->format == 'c') {
595 return INT2FIX(*(char *)p);
596 }
597 else if (member->format == 'C') {
598 return INT2FIX(*(unsigned char *)p);
599 }
600
601 union {
602 short s;
603 unsigned short us;
604 int i;
605 unsigned int ui;
606 long l;
607 unsigned long ul;
608 LONG_LONG ll;
609 unsigned LONG_LONG ull;
610 int16_t i16;
611 uint16_t u16;
612 int32_t i32;
613 uint32_t u32;
614 int64_t i64;
615 uint64_t u64;
616 intptr_t iptr;
617 uintptr_t uptr;
618 float f;
619 double d;
620 } val;
621
622 if (!native_endian_p) {
623 MEMCPY(&val, p, uint8_t, member->size);
624 switch_endianness((uint8_t *)&val, member->size);
625 }
626 else {
627 MEMCPY(&val, p, uint8_t, member->size);
628 }
629
630 switch (member->format) {
631 case 's':
632 if (member->native_size_p) {
633 return INT2FIX(val.s);
634 }
635 else {
636 return INT2FIX(val.i16);
637 }
638
639 case 'S':
640 case 'n':
641 case 'v':
642 if (member->native_size_p) {
643 return UINT2NUM(val.us);
644 }
645 else {
646 return INT2FIX(val.u16);
647 }
648
649 case 'i':
650 return INT2NUM(val.i);
651
652 case 'I':
653 return UINT2NUM(val.ui);
654
655 case 'l':
656 if (member->native_size_p) {
657 return LONG2NUM(val.l);
658 }
659 else {
660 return LONG2NUM(val.i32);
661 }
662
663 case 'L':
664 case 'N':
665 case 'V':
666 if (member->native_size_p) {
667 return ULONG2NUM(val.ul);
668 }
669 else {
670 return ULONG2NUM(val.u32);
671 }
672
673 case 'f':
674 case 'e':
675 case 'g':
676 return DBL2NUM(val.f);
677
678 case 'q':
679 if (member->native_size_p) {
680 return LL2NUM(val.ll);
681 }
682 else {
683#if SIZEOF_INT64_T == SIZEOF_LONG
684 return LONG2NUM(val.i64);
685#else
686 return LL2NUM(val.i64);
687#endif
688 }
689
690 case 'Q':
691 if (member->native_size_p) {
692 return ULL2NUM(val.ull);
693 }
694 else {
695#if SIZEOF_UINT64_T == SIZEOF_LONG
696 return ULONG2NUM(val.u64);
697#else
698 return ULL2NUM(val.u64);
699#endif
700 }
701
702 case 'd':
703 case 'E':
704 case 'G':
705 return DBL2NUM(val.d);
706
707 case 'j':
708 return INTPTR2NUM(val.iptr);
709
710 case 'J':
711 return UINTPTR2NUM(val.uptr);
712
713 default:
715 }
716}
717
718/* Return a value of the extracted member. */
719VALUE
720rb_memory_view_extract_item_member(const void *ptr, const rb_memory_view_item_component_t *member, const size_t i)
721{
722 if (ptr == NULL) return Qnil;
723 if (member == NULL) return Qnil;
724 if (i >= member->repeat) return Qnil;
725
726 return extract_item_member(ptr, member, i);
727}
728
729/* Return a value that consists of item members.
730 * When an item is a single member, the return value is a single value.
731 * When an item consists of multiple members, an array will be returned. */
732VALUE
733rb_memory_view_extract_item_members(const void *ptr, const rb_memory_view_item_component_t *members, const size_t n_members)
734{
735 if (ptr == NULL) return Qnil;
736 if (members == NULL) return Qnil;
737 if (n_members == 0) return Qnil;
738
739 if (n_members == 1 && members[0].repeat == 1) {
740 return rb_memory_view_extract_item_member(ptr, members, 0);
741 }
742
743 size_t i, j;
744 VALUE item = rb_ary_new();
745 for (i = 0; i < n_members; ++i) {
746 for (j = 0; j < members[i].repeat; ++j) {
747 VALUE v = extract_item_member(ptr, &members[i], j);
748 rb_ary_push(item, v);
749 }
750 }
751
752 return item;
753}
754
755void
757{
758 if (view->item_desc.components == NULL) {
759 const char *err;
760 rb_memory_view_item_component_t **p_components =
761 (rb_memory_view_item_component_t **)&view->item_desc.components;
762 ssize_t n = rb_memory_view_parse_item_format(view->format, p_components, &view->item_desc.length, &err);
763 if (n < 0) {
764 rb_raise(rb_eRuntimeError,
765 "Unable to parse item format at %"PRIdSIZE" in \"%s\"",
766 (err - view->format), view->format);
767 }
768 }
769}
770
771/* Return a value that consists of item members in the given memory view. */
772VALUE
773rb_memory_view_get_item(rb_memory_view_t *view, const ssize_t *indices)
774{
775 void *ptr = rb_memory_view_get_item_pointer(view, indices);
776
777 if (view->format == NULL) {
778 return INT2FIX(*(uint8_t *)ptr);
779 }
780
781 if (view->item_desc.components == NULL) {
783 }
784
785 return rb_memory_view_extract_item_members(ptr, view->item_desc.components, view->item_desc.length);
786}
787
788static const rb_memory_view_entry_t *
789lookup_memory_view_entry(VALUE klass)
790{
791 VALUE entry_obj = rb_ivar_lookup(klass, id_memory_view, Qnil);
792 while (NIL_P(entry_obj)) {
793 klass = rb_class_superclass(klass);
794
795 if (klass == rb_cBasicObject || klass == rb_cObject)
796 return NULL;
797
798 entry_obj = rb_ivar_lookup(klass, id_memory_view, Qnil);
799 }
800
801 if (! rb_typeddata_is_kind_of(entry_obj, &memory_view_entry_data_type))
802 return NULL;
803
804 return (const rb_memory_view_entry_t *)RTYPEDDATA_DATA(entry_obj);
805}
806
807/* Examine whether the given object supports memory view. */
808bool
810{
811 VALUE klass = CLASS_OF(obj);
812 const rb_memory_view_entry_t *entry = lookup_memory_view_entry(klass);
813 if (entry)
814 return (* entry->available_p_func)(obj);
815 else
816 return false;
817}
818
819/* Obtain a memory view from obj, and substitute the information to view. */
820bool
822{
823 VALUE klass = CLASS_OF(obj);
824 const rb_memory_view_entry_t *entry = lookup_memory_view_entry(klass);
825 if (entry) {
826 if (!(*entry->available_p_func)(obj)) {
827 return false;
828 }
829
830 bool rv = (*entry->get_func)(obj, view, flags);
831 if (rv) {
832 view->_memory_view_entry = entry;
833 register_exported_object(view->obj);
834 }
835 return rv;
836 }
837 else
838 return false;
839}
840
841/* Release the memory view obtained from obj. */
842bool
844{
845 const rb_memory_view_entry_t *entry = view->_memory_view_entry;
846 if (entry) {
847 bool rv = true;
848 if (entry->release_func) {
849 rv = (*entry->release_func)(view->obj, view);
850 }
851 if (rv) {
852 unregister_exported_object(view->obj);
853 view->obj = Qnil;
854 xfree((void *)view->item_desc.components);
855 }
856 return rv;
857 }
858 else
859 return false;
860}
861
862void
863Init_MemoryView(void)
864{
865 exported_object_table = rb_init_identtable();
866
867 // exported_object_table is referred through rb_memory_view_exported_object_registry
868 // in -test-/memory_view extension.
870 0, &rb_memory_view_exported_object_registry_data_type,
871 exported_object_table);
872 rb_vm_register_global_object(obj);
873 rb_memory_view_exported_object_registry = obj;
874
875 id_memory_view = rb_intern_const("__memory_view__");
876}
#define RUBY_ASSERT(...)
Asserts that the given expression is truthy if and only if RUBY_DEBUG is truthy.
Definition assert.h:219
#define LONG_LONG
Definition long_long.h:38
#define ISSPACE
@old{rb_isspace}
Definition ctype.h:88
#define xfree
Old name of ruby_xfree.
Definition xmalloc.h:58
#define Qundef
Old name of RUBY_Qundef.
#define INT2FIX
Old name of RB_INT2FIX.
Definition long.h:48
#define ULONG2NUM
Old name of RB_ULONG2NUM.
Definition long.h:60
#define UNREACHABLE_RETURN
Old name of RBIMPL_UNREACHABLE_RETURN.
Definition assume.h:29
#define LL2NUM
Old name of RB_LL2NUM.
Definition long_long.h:30
#define CLASS_OF
Old name of rb_class_of.
Definition globals.h:205
#define ALLOC_N
Old name of RB_ALLOC_N.
Definition memory.h:399
#define LONG2NUM
Old name of RB_LONG2NUM.
Definition long.h:50
#define ULL2NUM
Old name of RB_ULL2NUM.
Definition long_long.h:31
#define INT2NUM
Old name of RB_INT2NUM.
Definition int.h:43
#define Qnil
Old name of RUBY_Qnil.
#define NIL_P
Old name of RB_NIL_P.
#define DBL2NUM
Old name of rb_float_new.
Definition double.h:29
#define T_CLASS
Old name of RUBY_T_CLASS.
Definition value_type.h:58
#define UINT2NUM
Old name of RB_UINT2NUM.
Definition int.h:46
int rb_typeddata_is_kind_of(VALUE obj, const rb_data_type_t *data_type)
Checks if the given object is of given kind.
Definition error.c:1381
VALUE rb_eRuntimeError
RuntimeError exception.
Definition error.c:1429
VALUE rb_exc_new_str(VALUE etype, VALUE str)
Identical to rb_exc_new_cstr(), except it takes a Ruby's string instead of C's.
Definition error.c:1482
void rb_warning(const char *fmt,...)
Issues a warning.
Definition error.c:497
VALUE rb_class_superclass(VALUE klass)
Queries the parent of the given class.
Definition object.c:2264
VALUE rb_cBasicObject
BasicObject class.
Definition object.c:59
VALUE rb_ary_new(void)
Allocates a new, empty array.
VALUE rb_ary_push(VALUE ary, VALUE elem)
Special case of rb_ary_cat() that it adds only one element.
#define rb_exc_new_cstr(exc, str)
Identical to rb_exc_new(), except it assumes the passed pointer is a pointer to a C string.
Definition string.h:1671
VALUE rb_ivar_set(VALUE obj, ID name, VALUE val)
Identical to rb_iv_set(), except it accepts the name as an ID instead of a C string.
Definition variable.c:2030
char * ptr
Pointer to the underlying memory region, of at least capa bytes.
Definition io.h:2
int len
Length of the buffer.
Definition io.h:8
const signed char ruby_digit36_to_number_table[]
Character to number mapping like 'a' -> 10, 'b' -> 11 etc.
Definition util.c:60
#define MEMCPY(p1, p2, type, n)
Handy macro to call memcpy.
Definition memory.h:372
Memory View.
void * rb_memory_view_get_item_pointer(rb_memory_view_t *view, const ssize_t *indices)
Calculate the location of the item indicated by the given indices.
bool rb_memory_view_is_row_major_contiguous(const rb_memory_view_t *view)
Return true if the data in the MemoryView view is row-major contiguous.
bool rb_memory_view_get(VALUE obj, rb_memory_view_t *memory_view, int flags)
If the given obj supports to export a MemoryView that conforms the given flags, this function fills v...
VALUE rb_memory_view_extract_item_members(const void *ptr, const rb_memory_view_item_component_t *members, const size_t n_members)
Return a value that consists of item members.
ssize_t rb_memory_view_item_size_from_format(const char *format, const char **err)
Calculate the number of bytes occupied by an element.
struct rb_memory_view_entry rb_memory_view_entry_t
Operations applied to a specific kind of a memory view.
bool rb_memory_view_release(rb_memory_view_t *memory_view)
Release the given MemoryView view and decrement the reference count of memory_view->obj.
void rb_memory_view_fill_contiguous_strides(const ssize_t ndim, const ssize_t item_size, const ssize_t *const shape, const bool row_major_p, ssize_t *const strides)
Fill the strides array with byte-Strides of a contiguous array of the given shape with the given elem...
bool rb_memory_view_available_p(VALUE obj)
Return true if obj supports to export a MemoryView.
bool rb_memory_view_is_column_major_contiguous(const rb_memory_view_t *view)
Return true if the data in the MemoryView view is column-major contiguous.
bool rb_memory_view_register(VALUE klass, const rb_memory_view_entry_t *entry)
Associates the passed class with the passed memory view entry.
bool rb_memory_view_init_as_byte_array(rb_memory_view_t *view, VALUE obj, void *data, const ssize_t len, const bool readonly)
Fill the members of view as an 1-dimensional byte array.
VALUE rb_memory_view_get_item(rb_memory_view_t *view, const ssize_t *indices)
ssize_t rb_memory_view_parse_item_format(const char *format, rb_memory_view_item_component_t **members, size_t *n_members, const char **err)
Deconstructs the passed format string, as describe in rb_memory_view_t::format.
void rb_memory_view_prepare_item_desc(rb_memory_view_t *view)
Fill the item_desc member of view.
#define RTYPEDDATA_DATA(v)
Convenient getter macro.
Definition rtypeddata.h:103
#define TypedData_Wrap_Struct(klass, data_type, sval)
Converts sval, a pointer to your struct, into a Ruby object.
Definition rtypeddata.h:461
struct rb_data_type_struct rb_data_type_t
This is the struct that holds necessary info for a struct.
Definition rtypeddata.h:205
rb_memory_view_get_func_t get_func
Exports a memory view from a Ruby object.
rb_memory_view_available_p_func_t available_p_func
Queries if an object understands memory view protocol.
rb_memory_view_release_func_t release_func
Releases a memory view that was previously generated using rb_memory_view_entry_t::get_func.
Memory view component metadata.
Definition memory_view.h:45
bool native_size_p
:FIXME: what is a "native" size is unclear.
Definition memory_view.h:50
size_t size
The component's size.
Definition memory_view.h:59
size_t repeat
How many numbers of components are there.
Definition memory_view.h:65
size_t offset
The component's offset.
Definition memory_view.h:56
bool little_endian_p
Endian of the component.
Definition memory_view.h:53
A MemoryView structure, rb_memory_view_t, is used for exporting objects' MemoryView.
Definition memory_view.h:77
ssize_t item_size
The number of bytes in each element.
const ssize_t * strides
ndim size array indicating the number of bytes to skip to go to the next element in each dimension.
ssize_t ndim
The number of dimension.
const struct rb_memory_view_entry * _memory_view_entry
DO NOT TOUCH THIS: The memory view entry for the internal use.
void * data
The pointer to the exported memory.
Definition memory_view.h:84
VALUE obj
The original object that has the memory exported via this memory view.
Definition memory_view.h:81
const ssize_t * sub_offsets
The offset in each dimension when this memory view exposes a nested array.
const ssize_t * shape
ndim size array indicating the number of elements in each dimension.
void * private_data
The private data for managing this exported memory.
const char * format
A string to describe the format of an element, or NULL for unsigned bytes.
ssize_t byte_size
The number of bytes in data.
Definition memory_view.h:87
bool readonly
true for readonly memory, false for writable memory.
Definition memory_view.h:90
uintptr_t ID
Type that represents a Ruby identifier such as a variable name.
Definition value.h:52
uintptr_t VALUE
Type that represents a Ruby object.
Definition value.h:40