CI

Guillermo Bescos · Guillermo Bescos · commit bf9c96836cbb · 2022-07-28T20:18:04.000Z
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -3,7 +3,9 @@ repos:
   rev: v3.2.0
   hooks:
   - id: trailing-whitespace
+    files : program/
   - id: end-of-file-fixer
+    files : program/
   - id: check-added-large-files
 - repo: local
   hooks:
diff --git a/program/c/src/oracle/model/clean b/program/c/src/oracle/model/clean
@@ -1,3 +1,2 @@
 #!/bin/sh
 rm -rfv bin
-
diff --git a/program/c/src/oracle/model/price_model.c b/program/c/src/oracle/model/price_model.c
@@ -17,14 +17,14 @@ price_model_core( uint64_t  cnt,
      optimized mergesort (merge with an unrolled insertion sorting
      network small n base cases).  The best case is ~0.5 n lg n compares
      and the average and worst cases are ~n lg n compares.
-     
+
      While not completely data oblivious, this has quite low variance in
      operation count practically and this is _better_ than quicksort's
      average case and quicksort's worst case is a computational
      denial-of-service and timing attack vulnerable O(n^2).  Unlike
      quicksort, this is also stable (but this stability does not
      currently matter ... it might be a factor in future models).
-     
+
      A data oblivious sorting network approach might be viable here with
      and would have a completely deterministic operations count.  It
      currently isn't used as the best known practical approaches for
@@ -101,7 +101,7 @@ price_model_core( uint64_t  cnt,
 
     *_p50 = avg_2_int64( vl, vr );
   }
-  
+
   /* Extract the p75 (this is the mirror image of the p25 case) */
 
   uint64_t p75_idx = cnt - ((uint64_t)1) - p25_idx;
@@ -110,4 +110,3 @@ price_model_core( uint64_t  cnt,
 
   return sort_quote;
 }
-
diff --git a/program/c/src/oracle/model/run_tests b/program/c/src/oracle/model/run_tests
@@ -15,4 +15,3 @@ $CC test_price_model.c price_model.c -o bin/test_price_model || exit 1
 bin/test_price_model || exit 1
 
 echo all tests passed
-
diff --git a/program/c/src/oracle/model/test_price_model.c b/program/c/src/oracle/model/test_price_model.c
@@ -66,4 +66,3 @@ main( int     argc,
   printf( "pass\n" );
   return 0;
 }
-
diff --git a/program/c/src/oracle/oracle.c b/program/c/src/oracle/oracle.c
@@ -563,4 +563,3 @@ extern uint64_t c_entrypoint(const uint8_t *input)
   }
   return dispatch( prm, ka );
 }
-
diff --git a/program/c/src/oracle/oracle.h b/program/c/src/oracle/oracle.h
@@ -13,7 +13,7 @@ extern "C" {
 // defines to u32 (even with ULL suffix)
 const uint64_t SUCCESSFULLY_UPDATED_AGGREGATE = 1000ULL;
 
-// The size of the "time machine" account defined in the 
+// The size of the "time machine" account defined in the
 // Rust portion of the codebase.
 const uint64_t TIME_MACHINE_STRUCT_SIZE = 1864ULL;
 
diff --git a/program/c/src/oracle/pd.h b/program/c/src/oracle/pd.h
@@ -188,4 +188,3 @@ static inline void pd_sqrt( pd_t *r, pd_t *val, const int64_t *f )
 #ifdef __cplusplus
 }
 #endif
-
diff --git a/program/c/src/oracle/sort/clean b/program/c/src/oracle/sort/clean
@@ -1,3 +1,2 @@
 #!/bin/sh
 rm -rfv bin
-
diff --git a/program/c/src/oracle/sort/run_tests b/program/c/src/oracle/sort/run_tests
@@ -15,4 +15,3 @@ $CC test_sort_stable.c -o bin/test_sort_stable || exit 1
 bin/test_sort_stable || exit 1
 
 echo all tests passed
-
diff --git a/program/c/src/oracle/sort/sort_stable_base_gen.c b/program/c/src/oracle/sort/sort_stable_base_gen.c
@@ -92,4 +92,3 @@ main( int     argc,
   sort_gen( n );
   return 0;
 }
-
diff --git a/program/c/src/oracle/sort/test_sort_stable.c b/program/c/src/oracle/sort/test_sort_stable.c
@@ -49,11 +49,11 @@ main( int     argc,
   prng_t _prng[1];
   prng_t * prng = prng_join( prng_new( _prng, (uint32_t)0, (uint64_t)0 ) );
 
-  int ctr = 0;                                                                                                                      
+  int ctr = 0;
   for( int iter=0; iter<10000000; iter++ ) {
     if( !ctr ) { printf( "Randomized: Completed %i iterations\n", iter ); ctr = 100000; }
     ctr--;
-    
+
     int n = (int)(prng_uint32( prng ) % (uint32_t)(N+1)); /* In [0,N], approx uniform IID */
     for( int i=0; i<n; i++ ) x[i] = (int)((prng_uint32( prng ) & UINT32_C( 0x00ff0000 )) | (uint32_t)i);
     for( int i=0; i<n; i++ ) w[i] = x[i];
@@ -74,10 +74,9 @@ main( int     argc,
   }
 
   prng_delete( prng_leave( prng ) );
- 
+
   printf( "pass\n" );
   return 0;
 }
 
 #undef BEFORE
-
diff --git a/program/c/src/oracle/sort/tmpl/sort_stable.c b/program/c/src/oracle/sort/tmpl/sort_stable.c
@@ -145,12 +145,12 @@ SORT_IMPL(stable_node)( SORT_KEY_T * x,
   SORT_KEY_T * tr = t + nl;
   SORT_IDX_T   nr = n - nl;
   SORT_KEY_T * yr = SORT_IMPL(stable_node)( xr,nr, tr );
-  
+
   /* If left subsort result ended up in orig array, merge into temp
      array.  Otherwise, merge into orig array. */
 
   if( yl==xl ) x = t;
- 
+
   /* At this point, note that yl does not overlap with the location for
      merge output at this point.  yr might overlap (with the right half)
      with the location for merge output but this will still work in that
@@ -193,4 +193,3 @@ SORT_IMPL(stable)( SORT_KEY_T * key,
 #undef SORT_IDX_T
 #undef SORT_KEY_T
 #undef SORT_NAME
-
diff --git a/program/c/src/oracle/upd_aggregate.h b/program/c/src/oracle/upd_aggregate.h
@@ -237,4 +237,3 @@ static inline bool upd_aggregate( pc_price_t *ptr, uint64_t slot, int64_t timest
 #ifdef __cplusplus
 }
 #endif
-
diff --git a/program/c/src/oracle/util/avg.h b/program/c/src/oracle/util/avg.h
@@ -66,8 +66,8 @@ avg_2_int64( int64_t x,
   /* Similar considerations as above */
 
 # if 1 /* Fewer ops but less parallel issue */
-  /* x+y = x+2^63 + y+2^63 - 2^64 ... exact ops 
-         = ux     + uy     - 2^64 ... exact ops where ux and uy are exactly representable as a 64-bit uint 
+  /* x+y = x+2^63 + y+2^63 - 2^64 ... exact ops
+         = ux     + uy     - 2^64 ... exact ops where ux and uy are exactly representable as a 64-bit uint
          = uz     + 2^64 c - 2^64 ... exact ops where uz is a 64-bit uint and c is in [0,1].
      Thus, as before
        uz = ux+uy   ... c ops
@@ -86,7 +86,7 @@ avg_2_int64( int64_t x,
      using the signed and unsigned adds are the same operation binary
      in we have:
        x+2^63              ... exact ops
-       ==x+/-2^63 mod 2^64 ... exact ops 
+       ==x+/-2^63 mod 2^64 ... exact ops
        ==x+/-2^63          ... c ops  */
    uint64_t t = (uint64_t)x;
    uint64_t z = t + (uint64_t)y;
@@ -165,4 +165,3 @@ PYTH_ORACLE_UTIL_AVG_DECL( avg_int32, int32_t )
 #endif
 
 #endif /* _pyth_oracle_util_avg_h_ */
-
diff --git a/program/c/src/oracle/util/clean b/program/c/src/oracle/util/clean
@@ -1,3 +1,2 @@
 #!/bin/sh
 rm -rfv bin
-
diff --git a/program/c/src/oracle/util/hash.h b/program/c/src/oracle/util/hash.h
@@ -71,4 +71,3 @@ hash_inverse_uint64( uint64_t x ) {
 #endif
 
 #endif /* _pyth_oracle_util_hash_h_ */
-
diff --git a/program/c/src/oracle/util/prng.h b/program/c/src/oracle/util/prng.h
@@ -5,7 +5,7 @@
    generator.  Supports parallel generation, interprocess shared memory
    usage, checkpointing, random access, reversible, atomic, etc.  Passes
    extremely strict tests of randomness.
-   
+
    Assumes hash.h provides a high quality 64<>64-bit integer hash
    functions (i.e. full avalanche) with the property hash_uint64(0)==0
    and hash_uint64(i) for i in [0,2^64) yields a permutation of [0,2^64)
@@ -88,7 +88,7 @@ prng_private_contract( uint64_t seq ) {
    state of a _prng and returns ownership of the underlying memory
    region to the caller.  There should be no joins in the system on the
    prng.  Returns a pointer to the underlying memory region.
-   
+
    FIXME: CONSIDER FLATTENING ALIGN? */
 
 static inline uint64_t prng_footprint( void ) { return (uint64_t)sizeof ( prng_t ); }
@@ -143,7 +143,7 @@ prng_idx_set( prng_t * prng,
    possible values of of a signed int uniform IID can be obtained by
    casting the output of the unsigned generator of the same, assuming
    typical twos complement arithmetic platform.)
-   
+
    The theory for this that hash_uint64(i) for i in [0,2^64) specifies a
    random looking permutation of the integers in [0,2^64).  Returning
    the low order bits of this random permutation then yields a high
@@ -207,7 +207,7 @@ static inline int64_t prng_int64( prng_t * prng ) { return (int64_t)( prng_uint6
    goes from [i/N,(i+1)/N) where i is in [0,N).  For single (double)
    precision, "float" ("double"), the largest N for which the range of
    each interval is _exactly_ representable is N = 2^24 (2^53).
-   
+
    Given then a uniform IID uint32_t random input, the
    prng_uint32_to_float_c0 converter output is as though an continuous
    IID uniform random in [0,1) was generated and then rounded down to
@@ -246,7 +246,7 @@ static inline int64_t prng_int64( prng_t * prng ) { return (int64_t)( prng_uint6
    Note that it is possible to make converters that will handle exactly
    rounding toward all possible floating point representations in [0,1]
    but this are significantly more expensive.
-   
+
    Assumes IEEE-754 style float and doubles.
 
    FIXME: ADD UNIT TEST COVERAGE */
diff --git a/program/c/src/oracle/util/run_tests b/program/c/src/oracle/util/run_tests
@@ -52,4 +52,3 @@ bin/test_avg   || exit 1
 #bin/test_prng_battery 4 0 0 || exit 1 # BigCrush: Takes >~3 hours (seq 0, idx 0)
 
 echo all tests passed
-
diff --git a/program/c/src/oracle/util/sar.h b/program/c/src/oracle/util/sar.h
@@ -71,4 +71,3 @@ sar_int64( int64_t x,
 #endif
 
 #endif /* _pyth_oracle_util_sar_h_ */
-
diff --git a/program/c/src/oracle/util/test_align.c b/program/c/src/oracle/util/test_align.c
@@ -17,7 +17,7 @@ main( int     argc,
   prng_t _prng[1];
   prng_t * prng = prng_join( prng_new( _prng, (uint32_t)0, (uint64_t)0 ) );
 
-  int ctr = 0;                                                                                                                      
+  int ctr = 0;
   for( int i=0; i<1000000000; i++ ) {
     if( !ctr ) { printf( "Completed %i iterations\n", i ); ctr = 10000000; }
     ctr--;
@@ -74,4 +74,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_avg.c b/program/c/src/oracle/util/test_avg.c
@@ -10,12 +10,12 @@ main( int     argc,
   prng_t * prng = prng_join( prng_new( _prng, (uint32_t)0, (uint64_t)0 ) );
 
   int ctr;
-  
-  ctr = 0;                                                                                                                      
+
+  ctr = 0;
   for( int i=0; i<1000000000; i++ ) {
     if( !ctr ) { printf( "reg: Completed %i iterations\n", i ); ctr = 10000000; }
     ctr--;
-     
+
 #   define TEST(w) do {                                                                      \
       uint##w##_t x = prng_uint##w( prng );                                                  \
       uint##w##_t y = prng_uint##w( prng );                                                  \
@@ -140,4 +140,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_hash.c b/program/c/src/oracle/util/test_hash.c
@@ -56,4 +56,3 @@ main( int     argc,
   printf( "pass\n" );
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_prng.c b/program/c/src/oracle/util/test_prng.c
@@ -174,4 +174,3 @@ main( int     argc,
   printf( "pass\n" );
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_prng_battery.c b/program/c/src/oracle/util/test_prng_battery.c
@@ -89,4 +89,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_round.c b/program/c/src/oracle/util/test_round.c
@@ -28,4 +28,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/test_sar.c b/program/c/src/oracle/util/test_sar.c
@@ -12,7 +12,7 @@ main( int     argc,
   /* FIXME: EXPLICT COVERAGE OF EDGE CASES (PROBABLY STATICALLY FULLY
      SAMPLED ALREADY THOUGH FOR 8 AND 16 BIT TYPES) */
 
-  int ctr = 0;                                                                                                                      
+  int ctr = 0;
   for( int i=0; i<1000000000; i++ ) {
     if( !ctr ) { printf( "Completed %i iterations\n", i ); ctr = 10000000; }
     ctr--;
@@ -46,4 +46,3 @@ main( int     argc,
 
   return 0;
 }
-
diff --git a/program/c/src/oracle/util/util.h b/program/c/src/oracle/util/util.h
@@ -8,4 +8,3 @@
 #include "prng.h"   /* includes stdalign.h and hash.h */
 
 #endif /* _pyth_oracle_util_util_h_ */
-
diff --git a/program/rust/src/price_t_offsets.h b/program/rust/src/price_t_offsets.h
@@ -11,4 +11,4 @@ const size_t PRICE_T_AGGREGATE_PRICE_OFFSET = offsetof(struct pc_price, agg_) +
 const size_t PRICE_T_AGGREGATE_STATUS_OFFSET = offsetof(struct pc_price, agg_) + offsetof(struct pc_price_info, status_);
 const size_t PRICE_T_PREV_TIMESTAMP_OFFSET = offsetof(struct pc_price, prev_timestamp_);
 const size_t PRICE_T_PREV_CONF_OFFSET = offsetof(struct pc_price, prev_conf_);
-const size_t PRICE_T_PREV_AGGREGATE_OFFSET = offsetof(struct pc_price, prev_price_);
+const size_t PRICE_T_PREV_AGGREGATE_OFFSET = offsetof(struct pc_price, prev_price_);

Original file line number	Diff line number	Diff line change
`@@ -15,4 +15,3 @@ $CC test_price_model.c price_model.c -o bin/test_price_model \|\| exit 1`
`15`	`15`	`bin/test_price_model \|\| exit 1`
`16`	`16`
`17`	`17`	`echo all tests passed`
`18`		`-`
Original file line number	Diff line number	Diff line change
`@@ -66,4 +66,3 @@ main( int argc,`
`66`	`66`	`printf( "pass\n" );`
`67`	`67`	`return 0;`
`68`	`68`	`}`
`69`		`-`
Original file line number	Diff line number	Diff line change
`@@ -563,4 +563,3 @@ extern uint64_t c_entrypoint(const uint8_t *input)`
`563`	`563`	`}`
`564`	`564`	`return dispatch( prm, ka );`
`565`	`565`	`}`
`566`		`-`
Original file line number	Diff line number	Diff line change
`@@ -188,4 +188,3 @@ static inline void pd_sqrt( pd_t r, pd_t val, const int64_t *f )`
`188`	`188`	`#ifdef __cplusplus`
`189`	`189`	`}`
`190`	`190`	`#endif`
`191`		`-`
Original file line number	Diff line number	Diff line change
`@@ -15,4 +15,3 @@ $CC test_sort_stable.c -o bin/test_sort_stable \|\| exit 1`
`15`	`15`	`bin/test_sort_stable \|\| exit 1`
`16`	`16`
`17`	`17`	`echo all tests passed`
`18`		`-`