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