System/ReleaseNotes/J903

From J Wiki
Jump to: navigation, search

J903 beta development started in Dec 2020, and 903-beta-a was released 21 Dec 2020.

Changes to the J engine

Summary of Changes to the J Language in the release

  • New foreigns 9!:4 and 9!:5 support Nameref Caching, a way of avoiding name-lookup overhead especially useful when you have many locatives or long search paths.
  • New foreign u 4!:8 (adverb) produces a cached reference to u
  • Old foreigns 2!:2 and 2!:3 are removed from the language
  • +/!.0 y performs compensated summation (addition with improved accuracy)
  • x +/@:*"1!.0 y performs the computation at twice the precision of floats
  • x i.!.1 y assumes that x and y are both in nondescending order; faster when cells are integer lists. Supports IRS.

unreleased work in progress

  • bitwise booleans x m b. y implemented with 256-bit instructions (AVX and AVX2 only only)
  • comparison combinations on bytes performed with word-wide comparisons

J903 beta-i (the current beta)

  • (64-bit only) x ([ -. -.) y is implemented as a member of the i.-family, performing only one hash
  • (AVX2 only) all loops for arithmetic primitives with heterogeneous arguments recoded, faster
  • (> y) rewritten to avoid needless copying of fill
  • (AVX2 only) all loops for arithmetic primitives rewritten with better addressing modes, faster
  • (64-bit only) special code for -.&n reinstated, applying also to ([ -. -.)&n
  • Precomputed searches (m&i., (e.&n, (i.&1@:>&n, etc) support comparison tolerance

J903 beta-h

  • (AVX2 only) +/\ y, <./\ y, and >./\ y on float lists rewritten
  • (AVX2 only) all loops for arithmetic primitives with homogeneous arguments recoded, much faster on inplace arguments
  • (AVX2 only) internal memory-copying routine rewritten, faster for all sizes, but especially for non-multiples of 32 bytes

J903 beta-g

  • search for private names faster
  • debut of PPPP: pre-parsed parenthesized primitives. Parenthesized expressions that contain only primitives and do not cause executions of a verb (thus (+/ % #) but not (i. 1e8)) are parsed when an explicit entity is defined, avoiding the overhead of parsing each time the sentence is executed
  • arithmetic dyads + - % * >. <. coded to use 256-bit instructions when one argument is float and the other is integer (AVX2 only)
  • +./\ y, *./\ y, =/\ y, ~:/\ y recoded for boolean arrays of rank >1
  • All atomic suffix scans f/\. y recoded for boolean arrays of rank >1
  • =/\ y and ~:/\ y recoded for boolean list arguments

J903 beta-f

  • fix blunder in assert.: sentence no longer executed if 0=9!:34''
  • cached namerefs expose some of the value's characteristics to combining modifiers: IRS and immediate-opening
  • x i.!.1 y assumes that x and y are both in nondescending order; faster when cells are integer lists. Supports IRS.
  • Name lookups using the search path recoded, reducing the number of searches; Bloom filter added to public locales to allow fast skipping of locales with few names

J903 beta-e

  • +/ y, <./ y , and >./ y for floating-point y with rank >1 rewritten to use less cache bandwidth, >2x faster
  • +/!.0 y performs compensated summation (addition with improved accuracy)
  • x +/@:*"1!.0 y performs the computation at twice the precision of floats

J903 beta-d

  • x ]\ y, x [\ y, and x ,\ y return a virtual result when x<0 and there is no shard
  • f/ y faster on boolean arrays of rank >1 when f is a primitive logical operation
  • +/ y rewritten for boolean y, faster
  • special code for x f/@:g y with atomic f & g rewritten. Most special cases removed, as they are no longer faster than the normal code. Special code is used only when g cannot be executed in place.
  • New foreigns 9!:4 and 9!:5 support nameref caching, a way of avoiding name-lookup overhead especially useful when you have many locatives or long search paths. Put ". :: 1:'9!:5(1)' at the top of your script to see if you can use the feature.
  • New foreign u 4!:8 (adverb) produces a cached reference to u
  • Old foreigns 2!:2 and 2!:3 are removed from the language
  • |. y executes in place where possible
  • u"n is identical to u when n equals the ranks of u. If you need to generate a compound, use u"v.
  • in for_xyz. loops, a virtual block is used for xyz, and xyz_index cannot be modified inside the loop
  • Code for atomic/"1 y when 1-cells of y have length 2 rewritten

J903 beta-c withdrawn

J903 beta-b withdrawn

J903 beta-a

Changes to the base system

Changes to the Qt IDE