Changeset 15306


Ignore:
Timestamp:
06/04/20 08:25:14 (6 months ago)
Author:
Mark Evenson
Message:

Wire up the overhaul of java.nio.Buffer derived types

BasicVector_ByteBuffer, BasicVector_CharBuffer, BasicVector_IntBuffer,
ComplexVector_ByteBuffer, ComplexArray_ByteBuffer,
SimpleArray_ByteBuffer, and SimpleArray_CharBuffer are now wired into
the Cl:MAKE-ARRAY allocation strategy.

Use Java.Buffers.AllocationStrategy? enum to conditionalize use of
either arrays of primitive type or java.nio.Buffer creation strategy
for vector types. While eventually this might be able to be changed
at runtime, currently this is a compile-time option hardwired to use
the NIO allocation strategy.

Location:
trunk/abcl/src/org/armedbear/lisp
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/ByteArrayOutputStream.java

    r14466 r15306  
    3434package org.armedbear.lisp;
    3535
     36import org.armedbear.lisp.Java.Buffers.AllocationPolicy;
    3637import static org.armedbear.lisp.Lisp.*;
    3738
     
    135136        public LispObject execute(LispObject arg)
    136137        {
    137             if (arg instanceof ByteArrayOutputStream)
    138                 return new BasicVector_UnsignedByte8(((ByteArrayOutputStream)arg).getByteArray());
     138          if (arg instanceof ByteArrayOutputStream) {
     139            byte[] array = ((ByteArrayOutputStream)arg).getByteArray();
     140            if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     141              return new BasicVector_ByteBuffer(array, false);
     142            } else if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     143              return new BasicVector_UnsignedByte8(array);
     144            }
     145          }
    139146
    140             return type_error(this, Symbol.STREAM); // TODO
     147          return type_error(this, Symbol.STREAM); // TODO
    141148        }
    142149    };
  • trunk/abcl/src/org/armedbear/lisp/Java.java

    r15246 r15306  
    14211421        return message;
    14221422    }
     1423
     1424  // FIXME: better handled as a Lisp symbol?  With a Java enum, the
     1425  // compiler probably has a better chance to optimize.
     1426  public static class Buffers {
     1427    public enum AllocationPolicy { PRIMITIVE_ARRAY, NIO; };
     1428    public static AllocationPolicy active = AllocationPolicy.NIO;
     1429  }
     1430 
    14231431}
  • trunk/abcl/src/org/armedbear/lisp/make_array.java

    r13461 r15306  
    3434package org.armedbear.lisp;
    3535
     36import org.armedbear.lisp.Java.Buffers.AllocationPolicy;
    3637import static org.armedbear.lisp.Lisp.*;
    3738
     
    9495        if (rank == 1)
    9596          {
    96             AbstractVector v;
     97            AbstractVector v = null; // FIXME needed to get the compiler not to warn
    9798            LispObject arrayElementType = array.getElementType();
    98             if (arrayElementType == Symbol.CHARACTER)
     99            if (arrayElementType == Symbol.CHARACTER) {
    99100              v = new ComplexString(dimv[0], array, displacement);
    100             else if (arrayElementType == Symbol.BIT)
     101            } else if (arrayElementType == Symbol.BIT) {
    101102              v = new ComplexBitVector(dimv[0], array, displacement);
    102             else if (arrayElementType.equal(UNSIGNED_BYTE_8))
    103               v = new ComplexVector_UnsignedByte8(dimv[0], array, displacement);
    104             else if (arrayElementType.equal(UNSIGNED_BYTE_32))
     103            } else if (arrayElementType.equal(UNSIGNED_BYTE_8)) {
     104              if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     105                v = new ComplexVector_ByteBuffer(dimv[0], array, displacement);
     106              } else if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     107                v = new ComplexVector_UnsignedByte8(dimv[0], array, displacement);
     108              }
     109            } else if (arrayElementType.equal(UNSIGNED_BYTE_32)) {
    105110              v = new ComplexVector_UnsignedByte32(dimv[0], array, displacement);
    106             else
     111            } else {
    107112              v = new ComplexVector(dimv[0], array, displacement);
    108             if (fillPointer != NIL)
     113            }
     114            if (fillPointer != NIL) {
    109115              v.setFillPointer(fillPointer);
     116            }
    110117            return v;
    111118          }
     
    161168        else if (upgradedType.equal(UNSIGNED_BYTE_8))
    162169          {
    163             if (fillPointer != NIL || adjustable != NIL)
    164               v = new ComplexVector_UnsignedByte8(size);
    165             else
    166               v = new BasicVector_UnsignedByte8(size);
     170            if (fillPointer != NIL || adjustable != NIL) {
     171              if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     172                v = new ComplexVector_ByteBuffer(size);
     173              } else { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     174                v = new ComplexVector_UnsignedByte8(size);
     175              }
     176            } else {
     177              if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     178                v = new BasicVector_ByteBuffer(size);
     179              } else { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     180                v = new BasicVector_UnsignedByte8(size);
     181              }
     182            }
     183
    167184            defaultInitialElement = Fixnum.ZERO;
    168185          }
     
    170187                 fillPointer == NIL && adjustable == NIL)
    171188          {
    172             v = new BasicVector_UnsignedByte16(size);
     189            if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     190              v = new BasicVector_CharBuffer(size);
     191            } else { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     192              v = new BasicVector_UnsignedByte16(size);
     193            }
     194
    173195            defaultInitialElement = Fixnum.ZERO;
    174196          }
     
    177199            if (fillPointer != NIL || adjustable != NIL)
    178200              v = new ComplexVector_UnsignedByte32(size);
    179             else
    180               v = new BasicVector_UnsignedByte32(size);
     201            else {
     202              if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     203                v = new BasicVector_IntBuffer(size);
     204              } else { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     205                v = new BasicVector_UnsignedByte32(size);
     206              }
     207            }
    181208            defaultInitialElement = Fixnum.ZERO;
    182209          }
     
    235262            if (initialContents != NIL)
    236263              {
    237                 array = new SimpleArray_UnsignedByte8(dimv, initialContents);
    238               }
    239             else
    240               {
    241                 array = new SimpleArray_UnsignedByte8(dimv);
     264                if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     265                  array = new SimpleArray_ByteBuffer(dimv, initialContents);
     266                } else { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     267                  array = new SimpleArray_UnsignedByte8(dimv, initialContents);
     268                }
     269              }
     270            else
     271              {
     272                if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     273                  array = new SimpleArray_ByteBuffer(dimv);
     274                } else { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     275                  array = new SimpleArray_UnsignedByte8(dimv);
     276                }
     277                if (initialElementProvided != NIL) {
     278                  array.fill(initialElement);
     279                } else {
     280                  array.fill(Fixnum.ZERO);
     281                }
     282              }
     283          }
     284        else if (upgradedType.equal(UNSIGNED_BYTE_16)) {
     285          if (initialContents != NIL) {
     286            if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     287              array = new SimpleArray_CharBuffer(dimv, initialContents);
     288            } else { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     289              array = new SimpleArray_UnsignedByte16(dimv, initialContents);
     290            }
     291          } else {
     292            if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     293              array = new SimpleArray_CharBuffer(dimv);
     294            } else { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     295              array = new SimpleArray_UnsignedByte16(dimv);
     296            }
     297            if (initialElementProvided != NIL) {
     298              array.fill(initialElement);
     299            } else {
     300              array.fill(Fixnum.ZERO);
     301            }
     302          }
     303        }
     304        else if (upgradedType.equal(UNSIGNED_BYTE_32))
     305          {
     306            if (initialContents != NIL)
     307              {
     308                array = new SimpleArray_UnsignedByte32(dimv, initialContents);
     309              }
     310            else
     311              {
     312                array = new SimpleArray_UnsignedByte32(dimv);
    242313                if (initialElementProvided != NIL)
    243314                  array.fill(initialElement);
     
    246317              }
    247318          }
    248         else if (upgradedType.equal(UNSIGNED_BYTE_16))
    249           {
    250             if (initialContents != NIL)
    251               {
    252                 array = new SimpleArray_UnsignedByte16(dimv, initialContents);
    253               }
    254             else
    255               {
    256                 array = new SimpleArray_UnsignedByte16(dimv);
     319        else
     320          {
     321            if (initialContents != NIL)
     322              {
     323                array = new SimpleArray_T(dimv, upgradedType, initialContents);
     324              }
     325            else
     326              {
     327                array = new SimpleArray_T(dimv, upgradedType);
     328                if (initialElementProvided != NIL)
     329                  array.fill(initialElement);
     330                else
     331                  array.fill(NIL);
     332              }
     333          }
     334      }
     335    else
     336      {
     337        // Adjustable.
     338        if (upgradedType.equal(UNSIGNED_BYTE_8))
     339          {
     340            if (initialContents != NIL) {
     341              if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     342                array = new ComplexArray_ByteBuffer(dimv, initialContents);
     343              } else {  //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     344                array = new ComplexArray_UnsignedByte8(dimv, initialContents);
     345              }
     346            } else {
     347              if (Java.Buffers.active.equals(AllocationPolicy.NIO)) {
     348                array = new ComplexArray_ByteBuffer(dimv);
     349              } else  { //if (Java.Buffers.active.equals(AllocationPolicy.PRIMITIVE_ARRAY)) {
     350                array = new ComplexArray_UnsignedByte8(dimv);
     351              }
     352              if (initialElementProvided != NIL)
     353                array.fill(initialElement);
     354              else
     355                array.fill(Fixnum.ZERO);
     356              }
     357          }
     358        else if (upgradedType.equal(UNSIGNED_BYTE_32))
     359          {
     360            if (initialContents != NIL)
     361              {
     362                array = new ComplexArray_UnsignedByte32(dimv, initialContents);
     363              }
     364            else
     365              {
     366                array = new ComplexArray_UnsignedByte32(dimv);
    257367                if (initialElementProvided != NIL)
    258368                  array.fill(initialElement);
     
    261371              }
    262372          }
    263         else if (upgradedType.equal(UNSIGNED_BYTE_32))
    264           {
    265             if (initialContents != NIL)
    266               {
    267                 array = new SimpleArray_UnsignedByte32(dimv, initialContents);
    268               }
    269             else
    270               {
    271                 array = new SimpleArray_UnsignedByte32(dimv);
    272                 if (initialElementProvided != NIL)
    273                   array.fill(initialElement);
    274                 else
    275                   array.fill(Fixnum.ZERO);
    276               }
    277           }
    278         else
    279           {
    280             if (initialContents != NIL)
    281               {
    282                 array = new SimpleArray_T(dimv, upgradedType, initialContents);
    283               }
    284             else
    285               {
    286                 array = new SimpleArray_T(dimv, upgradedType);
     373        else
     374          {
     375            if (initialContents != NIL)
     376              {
     377                array = new ComplexArray(dimv, upgradedType, initialContents);
     378              }
     379            else
     380              {
     381                array = new ComplexArray(dimv, upgradedType);
    287382                if (initialElementProvided != NIL)
    288383                  array.fill(initialElement);
     
    292387          }
    293388      }
    294     else
    295       {
    296         // Adjustable.
    297         if (upgradedType.equal(UNSIGNED_BYTE_8))
    298           {
    299             if (initialContents != NIL)
    300               {
    301                 array = new ComplexArray_UnsignedByte8(dimv, initialContents);
    302               }
    303             else
    304               {
    305                 array = new ComplexArray_UnsignedByte8(dimv);
    306                 if (initialElementProvided != NIL)
    307                   array.fill(initialElement);
    308                 else
    309                   array.fill(Fixnum.ZERO);
    310               }
    311           }
    312         else if (upgradedType.equal(UNSIGNED_BYTE_32))
    313           {
    314             if (initialContents != NIL)
    315               {
    316                 array = new ComplexArray_UnsignedByte32(dimv, initialContents);
    317               }
    318             else
    319               {
    320                 array = new ComplexArray_UnsignedByte32(dimv);
    321                 if (initialElementProvided != NIL)
    322                   array.fill(initialElement);
    323                 else
    324                   array.fill(Fixnum.ZERO);
    325               }
    326           }
    327         else
    328           {
    329             if (initialContents != NIL)
    330               {
    331                 array = new ComplexArray(dimv, upgradedType, initialContents);
    332               }
    333             else
    334               {
    335                 array = new ComplexArray(dimv, upgradedType);
    336                 if (initialElementProvided != NIL)
    337                   array.fill(initialElement);
    338                 else
    339                   array.fill(NIL);
    340               }
    341           }
    342       }
    343389    return array;
    344390  }
Note: See TracChangeset for help on using the changeset viewer.