Github user kiszk commented on a diff in the pull request:
https://github.com/apache/spark/pull/19222#discussion_r138786324
--- Diff:
common/unsafe/src/main/java/org/apache/spark/unsafe/memory/ByteArrayMemoryBlock.java
---
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.unsafe.memory;
+
+import org.apache.spark.unsafe.Platform;
+
+/**
+ * A consecutive block of memory, starting at a {@link MemoryLocation}
with a fixed size.
+ */
+public class ByteArrayMemoryBlock extends MemoryLocation implements
MemoryBlock {
--- End diff --
@hvanhovell I agree with your concern about performance due to creating a
class hierarchy.
This implementation uses class hierarchy for two cases
1. Statically select target method using signature (e.g. Platform.getInt())
2. Dynamically select target method using receiver (e.g.
MemoryBlock.getBaseOffset())
Case 1 does not affect performance since it is resolved at javac. Case 2 is
your concern. Since case 2. is used mainly for `getBaseObject()` and
`getBaseOffset()` at performance critical path. They must be `final method`.
1. `MemoryLocation` is dropped
2. Several implementation classes extends `MemoryBlock` after making
`MemoryBlock` abstract` as follows:
```java
public abstract class MemoryBlock {
Object obj;
long offset;
public MemoryBlock(Object obj, long offset) {
this.obj = obj;
this.offset = offset;
}
public final Object getBaseObject() { return obj; }
public final long getBaseOffset() { return offset; }
abstract long size();
abstract void setPageNumber(int pageNum);
abstract int getPageNumber();
abstract void fill(byte value);
abstract MemoryBlock allocate(long offset, long size);
}
```
What do you think?
---
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
