Skip to content

Commit 35b60f9

Browse files
minborgminborg
committedAug 10, 2023
8298095: Refine implSpec for SegmentAllocator
Reviewed-by: mcimadamore
·
jdk-25+17jdk-22-ga
1 parent 6dba202 commit 35b60f9

File tree

1 file changed

+228
-102
lines changed

1 file changed

+228
-102
lines changed
 

‎src/java.base/share/classes/java/lang/foreign/SegmentAllocator.java

+228-102
Original file line numberDiff line numberDiff line change
@@ -77,8 +77,7 @@
7777
public interface SegmentAllocator {
7878

7979
/**
80-
* Converts a Java string into a UTF-8 encoded, null-terminated C string,
81-
* storing the result into a memory segment.
80+
* {@return a new memory segment with a Java string converted into a UTF-8 encoded, null-terminated C string}
8281
* <p>
8382
* This method always replaces malformed-input and unmappable-character
8483
* sequences with this charset's default replacement byte array. The
@@ -90,209 +89,329 @@ public interface SegmentAllocator {
9089
* the string, such as {@link MemorySegment#getUtf8String(long)}, the string
9190
* will appear truncated when read again.
9291
*
93-
* @implSpec the default implementation for this method copies the contents of the provided Java string
92+
* @implSpec The default implementation for this method copies the contents of the provided Java string
9493
* into a new memory segment obtained by calling {@code this.allocate(str.length() + 1)}.
9594
* @param str the Java string to be converted into a C string.
96-
* @return a new native segment containing the converted C string.
9795
*/
9896
default MemorySegment allocateUtf8String(String str) {
9997
Objects.requireNonNull(str);
10098
return Utils.toCString(str.getBytes(StandardCharsets.UTF_8), this);
10199
}
102100

103101
/**
104-
* Allocates a memory segment with the given layout and initializes it with the given byte value.
105-
* @implSpec the default implementation for this method calls {@code this.allocate(layout)}.
102+
* {@return a new memory segment initialized with the provided {@code byte} {@code value} as
103+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
104+
*
105+
* @implSpec The default implementation is equivalent to:
106+
* {@snippet lang=java :
107+
* MemorySegment seg = allocate(Objects.requireNonNull(layout));
108+
* seg.set(layout, 0, value);
109+
* return seg;
110+
* }
111+
*
106112
* @param layout the layout of the block of memory to be allocated.
107-
* @param value the value to be set on the newly allocated memory block.
108-
* @return a segment for the newly allocated memory block.
113+
* @param value the value to be set in the newly allocated memory segment.
109114
*/
110115
default MemorySegment allocate(ValueLayout.OfByte layout, byte value) {
111116
Objects.requireNonNull(layout);
112117
VarHandle handle = layout.varHandle();
113-
MemorySegment addr = allocate(layout);
114-
handle.set(addr, value);
115-
return addr;
118+
MemorySegment seg = allocate(layout);
119+
handle.set(seg, value);
120+
return seg;
116121
}
117122

118123
/**
119-
* Allocates a memory segment with the given layout and initializes it with the given char value.
120-
* @implSpec the default implementation for this method calls {@code this.allocate(layout)}.
124+
* {@return a new memory segment initialized with the provided {@code char} {@code value} as
125+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
126+
*
127+
* @implSpec The default implementation is equivalent to:
128+
* {@snippet lang=java :
129+
* MemorySegment seg = allocate(Objects.requireNonNull(layout));
130+
* seg.set(layout, 0, value);
131+
* return seg;
132+
* }
133+
*
121134
* @param layout the layout of the block of memory to be allocated.
122-
* @param value the value to be set on the newly allocated memory block.
123-
* @return a segment for the newly allocated memory block.
135+
* @param value the value to be set in the newly allocated memory segment.
124136
*/
125137
default MemorySegment allocate(ValueLayout.OfChar layout, char value) {
126138
Objects.requireNonNull(layout);
127139
VarHandle handle = layout.varHandle();
128-
MemorySegment addr = allocate(layout);
129-
handle.set(addr, value);
130-
return addr;
140+
MemorySegment seg = allocate(layout);
141+
handle.set(seg, value);
142+
return seg;
131143
}
132144

133145
/**
134-
* Allocates a memory segment with the given layout and initializes it with the given short value.
135-
* @implSpec the default implementation for this method calls {@code this.allocate(layout)}.
146+
* {@return a new memory segment initialized with the provided {@code short} {@code value} as
147+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
148+
*
149+
* @implSpec The default implementation is equivalent to:
150+
* {@snippet lang=java :
151+
* MemorySegment seg = allocate(Objects.requireNonNull(layout));
152+
* seg.set(layout, 0, value);
153+
* return seg;
154+
* }
155+
*
136156
* @param layout the layout of the block of memory to be allocated.
137-
* @param value the value to be set on the newly allocated memory block.
138-
* @return a segment for the newly allocated memory block.
157+
* @param value the value to be set in the newly allocated memory segment.
139158
*/
140159
default MemorySegment allocate(ValueLayout.OfShort layout, short value) {
141160
Objects.requireNonNull(layout);
142161
VarHandle handle = layout.varHandle();
143-
MemorySegment addr = allocate(layout);
144-
handle.set(addr, value);
145-
return addr;
162+
MemorySegment seg = allocate(layout);
163+
handle.set(seg, value);
164+
return seg;
146165
}
147166

148167
/**
149-
* Allocates a memory segment with the given layout and initializes it with the given int value.
150-
* @implSpec the default implementation for this method calls {@code this.allocate(layout)}.
168+
* {@return a new memory segment initialized with the provided {@code int} {@code value} as
169+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
170+
*
171+
* @implSpec The default implementation is equivalent to:
172+
* {@snippet lang=java :
173+
* MemorySegment seg = allocate(Objects.requireNonNull(layout));
174+
* seg.set(layout, 0, value);
175+
* return seg;
176+
* }
177+
*
151178
* @param layout the layout of the block of memory to be allocated.
152-
* @param value the value to be set on the newly allocated memory block.
153-
* @return a segment for the newly allocated memory block.
179+
* @param value the value to be set in the newly allocated memory segment.
154180
*/
155181
default MemorySegment allocate(ValueLayout.OfInt layout, int value) {
156182
Objects.requireNonNull(layout);
157183
VarHandle handle = layout.varHandle();
158-
MemorySegment addr = allocate(layout);
159-
handle.set(addr, value);
160-
return addr;
184+
MemorySegment seg = allocate(layout);
185+
handle.set(seg, value);
186+
return seg;
161187
}
162188

163189
/**
164-
* Allocates a memory segment with the given layout and initializes it with the given float value.
165-
* @implSpec the default implementation for this method calls {@code this.allocate(layout)}.
190+
* {@return a new memory segment initialized with the provided {@code float} {@code value} as
191+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
192+
*
193+
* @implSpec The default implementation is equivalent to:
194+
* {@snippet lang=java :
195+
* MemorySegment seg = allocate(Objects.requireNonNull(layout));
196+
* seg.set(layout, 0, value);
197+
* return seg;
198+
* }
199+
*
166200
* @param layout the layout of the block of memory to be allocated.
167-
* @param value the value to be set on the newly allocated memory block.
168-
* @return a segment for the newly allocated memory block.
201+
* @param value the value to be set in the newly allocated memory segment.
169202
*/
170203
default MemorySegment allocate(ValueLayout.OfFloat layout, float value) {
171204
Objects.requireNonNull(layout);
172205
VarHandle handle = layout.varHandle();
173-
MemorySegment addr = allocate(layout);
174-
handle.set(addr, value);
175-
return addr;
206+
MemorySegment seg = allocate(layout);
207+
handle.set(seg, value);
208+
return seg;
176209
}
177210

178211
/**
179-
* Allocates a memory segment with the given layout and initializes it with the given long value.
180-
* @implSpec the default implementation for this method calls {@code this.allocate(layout)}.
212+
* {@return a new memory segment initialized with the provided {@code long} {@code value} as
213+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
214+
*
215+
* @implSpec The default implementation is equivalent to:
216+
* {@snippet lang=java :
217+
* MemorySegment seg = allocate(Objects.requireNonNull(layout));
218+
* seg.set(layout, 0, value);
219+
* return seg;
220+
* }
221+
*
181222
* @param layout the layout of the block of memory to be allocated.
182-
* @param value the value to be set on the newly allocated memory block.
183-
* @return a segment for the newly allocated memory block.
223+
* @param value the value to be set in the newly allocated memory segment.
184224
*/
185225
default MemorySegment allocate(ValueLayout.OfLong layout, long value) {
186226
Objects.requireNonNull(layout);
187227
VarHandle handle = layout.varHandle();
188-
MemorySegment addr = allocate(layout);
189-
handle.set(addr, value);
190-
return addr;
228+
MemorySegment seg = allocate(layout);
229+
handle.set(seg, value);
230+
return seg;
191231
}
192232

193233
/**
194-
* Allocates a memory segment with the given layout and initializes it with the given double value.
195-
* @implSpec the default implementation for this method calls {@code this.allocate(layout)}.
234+
* {@return a new memory segment initialized with the provided {@code double} {@code value} as
235+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
236+
*
237+
* @implSpec The default implementation is equivalent to:
238+
* {@snippet lang=java :
239+
* MemorySegment seg = allocate(Objects.requireNonNull(layout));
240+
* seg.set(layout, 0, value);
241+
* return seg;
242+
* }
243+
*
196244
* @param layout the layout of the block of memory to be allocated.
197-
* @param value the value to be set on the newly allocated memory block.
198-
* @return a segment for the newly allocated memory block.
245+
* @param value the value to be set in the newly allocated memory segment.
199246
*/
200247
default MemorySegment allocate(ValueLayout.OfDouble layout, double value) {
201248
Objects.requireNonNull(layout);
202249
VarHandle handle = layout.varHandle();
203-
MemorySegment addr = allocate(layout);
204-
handle.set(addr, value);
205-
return addr;
250+
MemorySegment seg = allocate(layout);
251+
handle.set(seg, value);
252+
return seg;
206253
}
207254

208255
/**
209-
* Allocates a memory segment with the given layout and initializes it with the given address value.
256+
* {@return a new memory segment initialized with the address of the provided {@code value} as
257+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
258+
* <p>
210259
* The address value might be narrowed according to the platform address size (see {@link ValueLayout#ADDRESS}).
211-
* @implSpec the default implementation for this method calls {@code this.allocate(layout)}.
260+
*
261+
* @implSpec The default implementation is equivalent to:
262+
* {@snippet lang=java :
263+
* Objects.requireNonNull(value);
264+
* MemorySegment seg = allocate(Objects.requireNonNull(layout));
265+
* seg.set(layout, 0, value);
266+
* return seg;
267+
* }
268+
*
212269
* @param layout the layout of the block of memory to be allocated.
213-
* @param value the value to be set on the newly allocated memory block.
214-
* @return a segment for the newly allocated memory block.
270+
* @param value the value to be set in the newly allocated memory segment.
215271
*/
216272
default MemorySegment allocate(AddressLayout layout, MemorySegment value) {
217273
Objects.requireNonNull(value);
218274
Objects.requireNonNull(layout);
219-
MemorySegment segment = allocate(layout);
220-
layout.varHandle().set(segment, value);
221-
return segment;
275+
MemorySegment seg = allocate(layout);
276+
layout.varHandle().set(seg, value);
277+
return seg;
222278
}
223279

224280
/**
225-
* Allocates a memory segment with the given layout and initializes it with the given byte elements.
226-
* @implSpec the default implementation for this method calls {@code this.allocateArray(layout, array.length)}.
281+
* {@return a new memory segment with a {@linkplain MemorySegment#byteSize() byteSize()} of
282+
* {@code E*layout.byteSize()} initialized with the provided {@code E} {@code byte} {@code elements} as
283+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
284+
*
285+
* @implSpec The default implementation is equivalent to:
286+
* {@snippet lang=java :
287+
* int size = Objects.requireNonNull(elements).length;
288+
* MemorySegment seg = allocateArray(Objects.requireNonNull(elementLayout), size);
289+
* MemorySegment.copy(elements, 0, seg, elementLayout, 0, size);
290+
* return seg;
291+
* }
292+
*
227293
* @param elementLayout the element layout of the array to be allocated.
228-
* @param elements the byte elements to be copied to the newly allocated memory block.
229-
* @return a segment for the newly allocated memory block.
294+
* @param elements the short elements to be copied to the newly allocated memory block.
230295
*/
231296
default MemorySegment allocateArray(ValueLayout.OfByte elementLayout, byte... elements) {
232297
return copyArrayWithSwapIfNeeded(elements, elementLayout, MemorySegment::ofArray);
233298
}
234299

235300
/**
236-
* Allocates a memory segment with the given layout and initializes it with the given short elements.
237-
* @implSpec the default implementation for this method calls {@code this.allocateArray(layout, array.length)}.
301+
* {@return a new memory segment with a {@linkplain MemorySegment#byteSize() byteSize()} of
302+
* {@code E*layout.byteSize()} initialized with the provided {@code E} {@code short} {@code elements} as
303+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
304+
*
305+
* @implSpec The default implementation is equivalent to:
306+
* {@snippet lang=java :
307+
* int size = Objects.requireNonNull(elements).length;
308+
* MemorySegment seg = allocateArray(Objects.requireNonNull(elementLayout), size);
309+
* MemorySegment.copy(elements, 0, seg, elementLayout, 0, size);
310+
* return seg;
311+
* }
312+
*
238313
* @param elementLayout the element layout of the array to be allocated.
239-
* @param elements the short elements to be copied to the newly allocated memory block.
240-
* @return a segment for the newly allocated memory block.
314+
* @param elements the short elements to be copied to the newly allocated memory block.
241315
*/
242316
default MemorySegment allocateArray(ValueLayout.OfShort elementLayout, short... elements) {
243317
return copyArrayWithSwapIfNeeded(elements, elementLayout, MemorySegment::ofArray);
244318
}
245319

246320
/**
247-
* Allocates a memory segment with the given layout and initializes it with the given char elements.
248-
* @implSpec the default implementation for this method calls {@code this.allocateArray(layout, array.length)}.
321+
* {@return a new memory segment with a {@linkplain MemorySegment#byteSize() byteSize()} of
322+
* {@code E*layout.byteSize()} initialized with the provided {@code E} {@code char} {@code elements} as
323+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
324+
*
325+
* @implSpec The default implementation is equivalent to:
326+
* {@snippet lang=java :
327+
* int size = Objects.requireNonNull(elements).length;
328+
* MemorySegment seg = allocateArray(Objects.requireNonNull(elementLayout), size);
329+
* MemorySegment.copy(elements, 0, seg, elementLayout, 0, size);
330+
* return seg;
331+
* }
332+
*
249333
* @param elementLayout the element layout of the array to be allocated.
250-
* @param elements the char elements to be copied to the newly allocated memory block.
251-
* @return a segment for the newly allocated memory block.
334+
* @param elements the short elements to be copied to the newly allocated memory block.
252335
*/
253336
default MemorySegment allocateArray(ValueLayout.OfChar elementLayout, char... elements) {
254337
return copyArrayWithSwapIfNeeded(elements, elementLayout, MemorySegment::ofArray);
255338
}
256339

257340
/**
258-
* Allocates a memory segment with the given layout and initializes it with the given int elements.
259-
* @implSpec the default implementation for this method calls {@code this.allocateArray(layout, array.length)}.
341+
* {@return a new memory segment with a {@linkplain MemorySegment#byteSize() byteSize()} of
342+
* {@code E*layout.byteSize()} initialized with the provided {@code E} {@code int} {@code elements} as
343+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
344+
*
345+
* @implSpec The default implementation is equivalent to:
346+
* {@snippet lang=java :
347+
* int size = Objects.requireNonNull(elements).length;
348+
* MemorySegment seg = allocateArray(Objects.requireNonNull(elementLayout), size);
349+
* MemorySegment.copy(elements, 0, seg, elementLayout, 0, size);
350+
* return seg;
351+
* }
352+
*
260353
* @param elementLayout the element layout of the array to be allocated.
261-
* @param elements the int elements to be copied to the newly allocated memory block.
262-
* @return a segment for the newly allocated memory block.
354+
* @param elements the short elements to be copied to the newly allocated memory block.
263355
*/
264356
default MemorySegment allocateArray(ValueLayout.OfInt elementLayout, int... elements) {
265357
return copyArrayWithSwapIfNeeded(elements, elementLayout, MemorySegment::ofArray);
266358
}
267359

268360
/**
269-
* Allocates a memory segment with the given layout and initializes it with the given float elements.
270-
* @implSpec the default implementation for this method calls {@code this.allocateArray(layout, array.length)}.
361+
* {@return a new memory segment with a {@linkplain MemorySegment#byteSize() byteSize()} of
362+
* {@code E*layout.byteSize()} initialized with the provided {@code E} {@code float} {@code elements} as
363+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
364+
*
365+
* @implSpec The default implementation is equivalent to:
366+
* {@snippet lang=java :
367+
* int size = Objects.requireNonNull(elements).length;
368+
* MemorySegment seg = allocateArray(Objects.requireNonNull(elementLayout), size);
369+
* MemorySegment.copy(elements, 0, seg, elementLayout, 0, size);
370+
* return seg;
371+
* }
372+
*
271373
* @param elementLayout the element layout of the array to be allocated.
272-
* @param elements the float elements to be copied to the newly allocated memory block.
273-
* @return a segment for the newly allocated memory block.
374+
* @param elements the short elements to be copied to the newly allocated memory block.
274375
*/
275376
default MemorySegment allocateArray(ValueLayout.OfFloat elementLayout, float... elements) {
276377
return copyArrayWithSwapIfNeeded(elements, elementLayout, MemorySegment::ofArray);
277378
}
278379

279380
/**
280-
* Allocates a memory segment with the given layout and initializes it with the given long elements.
281-
* @implSpec the default implementation for this method calls {@code this.allocateArray(layout, array.length)}.
381+
* {@return a new memory segment with a {@linkplain MemorySegment#byteSize() byteSize()} of
382+
* {@code E*layout.byteSize()} initialized with the provided {@code E} {@code long} {@code elements} as
383+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
384+
*
385+
* @implSpec The default implementation is equivalent to:
386+
* {@snippet lang=java :
387+
* int size = Objects.requireNonNull(elements).length;
388+
* MemorySegment seg = allocateArray(Objects.requireNonNull(elementLayout), size);
389+
* MemorySegment.copy(elements, 0, seg, elementLayout, 0, size);
390+
* return seg;
391+
* }
392+
*
282393
* @param elementLayout the element layout of the array to be allocated.
283-
* @param elements the long elements to be copied to the newly allocated memory block.
284-
* @return a segment for the newly allocated memory block.
394+
* @param elements the short elements to be copied to the newly allocated memory block.
285395
*/
286396
default MemorySegment allocateArray(ValueLayout.OfLong elementLayout, long... elements) {
287397
return copyArrayWithSwapIfNeeded(elements, elementLayout, MemorySegment::ofArray);
288398
}
289399

290400
/**
291-
* Allocates a memory segment with the given layout and initializes it with the given double elements.
292-
* @implSpec the default implementation for this method calls {@code this.allocateArray(layout, array.length)}.
401+
* {@return a new memory segment with a {@linkplain MemorySegment#byteSize() byteSize()} of
402+
* {@code E*layout.byteSize()} initialized with the provided {@code E} {@code double} {@code elements} as
403+
* specified by the provided {@code layout} (i.e. byte ordering, alignment and size)}
404+
*
405+
* @implSpec The default implementation is equivalent to:
406+
* {@snippet lang=java :
407+
* int size = Objects.requireNonNull(elements).length;
408+
* MemorySegment seg = allocateArray(Objects.requireNonNull(elementLayout), size);
409+
* MemorySegment.copy(elements, 0, seg, elementLayout, 0, size);
410+
* return seg;
411+
* }
412+
*
293413
* @param elementLayout the element layout of the array to be allocated.
294-
* @param elements the double elements to be copied to the newly allocated memory block.
295-
* @return a segment for the newly allocated memory block.
414+
* @param elements the short elements to be copied to the newly allocated memory block.
296415
*/
297416
default MemorySegment allocateArray(ValueLayout.OfDouble elementLayout, double... elements) {
298417
return copyArrayWithSwapIfNeeded(elements, elementLayout, MemorySegment::ofArray);
@@ -301,31 +420,35 @@ default MemorySegment allocateArray(ValueLayout.OfDouble elementLayout, double..
301420
private <Z> MemorySegment copyArrayWithSwapIfNeeded(Z array, ValueLayout elementLayout,
302421
Function<Z, MemorySegment> heapSegmentFactory) {
303422
int size = Array.getLength(Objects.requireNonNull(array));
304-
MemorySegment addr = allocateArray(Objects.requireNonNull(elementLayout), size);
423+
MemorySegment seg = allocateArray(Objects.requireNonNull(elementLayout), size);
305424
if (size > 0) {
306425
MemorySegment.copy(heapSegmentFactory.apply(array), elementLayout, 0,
307-
addr, elementLayout.withOrder(ByteOrder.nativeOrder()), 0, size);
426+
seg, elementLayout.withOrder(ByteOrder.nativeOrder()), 0, size);
308427
}
309-
return addr;
428+
return seg;
310429
}
311430

312431
/**
313-
* Allocates a memory segment with the given layout.
314-
* @implSpec the default implementation for this method calls {@code this.allocate(layout.byteSize(), layout.byteAlignment())}.
432+
* {@return a new memory segment with the given layout}
433+
*
434+
* @implSpec The default implementation for this method calls
435+
* {@code this.allocate(layout.byteSize(), layout.byteAlignment())}.
436+
*
315437
* @param layout the layout of the block of memory to be allocated.
316-
* @return a segment for the newly allocated memory block.
317438
*/
318439
default MemorySegment allocate(MemoryLayout layout) {
319440
Objects.requireNonNull(layout);
320441
return allocate(layout.byteSize(), layout.byteAlignment());
321442
}
322443

323444
/**
324-
* Allocates a memory segment with the given element layout and size.
325-
* @implSpec the default implementation for this method calls {@code this.allocate(MemoryLayout.sequenceLayout(count, elementLayout))}.
445+
* {@return a new memory segment with the given {@code elementLayout} and {@code count}}
446+
*
447+
* @implSpec The default implementation for this method calls
448+
* {@code this.allocate(MemoryLayout.sequenceLayout(count, elementLayout))}.
449+
*
326450
* @param elementLayout the array element layout.
327451
* @param count the array element count.
328-
* @return a segment for the newly allocated memory block.
329452
* @throws IllegalArgumentException if {@code elementLayout.byteSize() * count} overflows.
330453
* @throws IllegalArgumentException if {@code count < 0}.
331454
*/
@@ -338,21 +461,23 @@ default MemorySegment allocateArray(MemoryLayout elementLayout, long count) {
338461
}
339462

340463
/**
341-
* Allocates a memory segment with the given size.
342-
* @implSpec the default implementation for this method calls {@code this.allocate(byteSize, 1)}.
464+
* {@return a new memory segment with the given {@code byteSize}}
465+
*
466+
* @implSpec The default implementation for this method calls
467+
* {@code this.allocate(byteSize, 1)}.
468+
*
343469
* @param byteSize the size (in bytes) of the block of memory to be allocated.
344-
* @return a segment for the newly allocated memory block.
345470
* @throws IllegalArgumentException if {@code byteSize < 0}
346471
*/
347472
default MemorySegment allocate(long byteSize) {
348473
return allocate(byteSize, 1);
349474
}
350475

351476
/**
352-
* Allocates a memory segment with the given size and alignment constraint.
477+
* {@return a new memory segment with the given {@code byteSize} and {@code byteAlignment}}
478+
*
353479
* @param byteSize the size (in bytes) of the block of memory to be allocated.
354480
* @param byteAlignment the alignment (in bytes) of the block of memory to be allocated.
355-
* @return a segment for the newly allocated memory block.
356481
* @throws IllegalArgumentException if {@code byteSize < 0}, {@code byteAlignment <= 0},
357482
* or if {@code byteAlignment} is not a power of 2.
358483
*/
@@ -365,6 +490,7 @@ default MemorySegment allocate(long byteSize) {
365490
* <p>
366491
* The returned allocator throws {@link IndexOutOfBoundsException} when a slice of the provided
367492
* segment with the requested size and alignment cannot be found.
493+
*
368494
* @implNote A slicing allocator is not <em>thread-safe</em>.
369495
*
370496
* @param segment the segment which the returned allocator should slice from.

1 commit comments

Comments
 (1)

openjdk-notifier[bot] commented on Aug 10, 2023

@openjdk-notifier[bot]
openjdk-notifier[bot]
on Aug 10, 2023

Review

Issues

Please sign in to comment.