END_TEST
START_TEST(test_ck_assert_uint_le)
{
unsigned int x = 2;
unsigned int y = 3;
ck_assert_uint_le(x, y);
ck_assert_uint_le(x, x);
ck_assert_uint_le(y, x);
#define LINENO_ck_assert_uint_le _STR(__LINE__)
}
static void
test_last_buffer_is_clipped (BT_TEST_ARGS)
{
BT_TEST_START;
GST_INFO ("-- arrange --");
GstElement *p =
gst_parse_launch
("buzztrax-test-audio-synth name=\"src\" ! fakesink async=false",
NULL);
BtTestAudioSynth *e =
(BtTestAudioSynth *) gst_bin_get_by_name (GST_BIN (p), "src");
GstBus *bus = gst_element_get_bus (p);
GST_INFO ("-- act --");
gst_element_set_state (p, GST_STATE_READY);
gst_element_set_context (p, ctx);
gst_element_set_state (p, GST_STATE_PAUSED);
gst_element_get_state (p, NULL, NULL, GST_CLOCK_TIME_NONE);
gst_element_seek (p, 1.0, GST_FORMAT_TIME, GST_SEEK_FLAG_FLUSH,
GST_SEEK_TYPE_SET, G_GUINT64_CONSTANT (0),
GST_SEEK_TYPE_SET, ticktime * 1.5);
gst_element_set_state (p, GST_STATE_PLAYING);
gst_element_get_state (p, NULL, NULL, GST_CLOCK_TIME_NONE);
gst_bus_poll (bus, GST_MESSAGE_EOS | GST_MESSAGE_ERROR, GST_CLOCK_TIME_NONE);
GST_INFO ("-- assert --");
BufferFields *bf0 = get_buffer_info (e, 0);
BufferFields *bf1 = get_buffer_info (e, 1);
ck_assert_uint64_le (bf1->duration, bf0->duration / 2);
ck_assert_uint_le (bf1->size, bf0->size / 2);
GST_INFO ("-- cleanup --");
gst_element_set_state (p, GST_STATE_NULL);
gst_object_unref (e);
gst_object_unref (p);
BT_TEST_END;
}
}END_TEST
/**
* Integer Factorization test
*/
START_TEST(test_integerfactorization){
ga_factor_list fl;
uint64_t n;
/**
* Attempt exact factorization for 2^64-1, no k-smoothness constraint.
* Expected PASS with 3*5*17*257*641*65537*6700417
*/
n = 18446744073709551615ULL;
ck_assert_int_ne (gaIFactorize(n, 0, 0, &fl), 0);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 3ULL), 1);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 5ULL), 1);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 17ULL), 1);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 257ULL), 1);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 641ULL), 1);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 65537ULL), 1);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 6700417ULL), 1);
ck_assert_uint_eq(gaIFLGetProduct(&fl), n);
/**
* Attempt exact factorization for 2^64-1, 4096-smooth constraint.
* Expected FAIL, because 2^64-1 possesses prime factors in excess of 4096.
*/
n = 18446744073709551615ULL;
ck_assert_int_eq (gaIFactorize(n, 0, 4096, &fl), 0);
/**
* Attempt approximate factorization for 2^64-1, no k-smoothness constraint.
* Unlimited growth permitted.
* Expected PASS, since 2^64-1 rounds up to 2^64 and 2^64 trivially factorizes.
*/
n = 18446744073709551615ULL;
ck_assert_int_ne (gaIFactorize(n, -1, 0, &fl), 0);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 2ULL), 64);
ck_assert_uint_eq(gaIFLGetGreatestFactor(&fl), 2);
ck_assert_int_ne (gaIFLIsOverflowed(&fl), 0);
/**
* Attempt exact factorization for 2196095973992233039, no k-smoothness constraint.
* 2196095973992233039 is a large, highly non-smooth number, with three enormous
* factors.
* Expected PASS *very quickly*, since it factorizes as 1299817*1299821*1299827
*/
n = 2196095973992233039ULL;
ck_assert_int_ne (gaIFactorize(n, 0, 0, &fl), 0);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 1299817ULL), 1);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 1299821ULL), 1);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 1299827ULL), 1);
ck_assert_uint_eq(gaIFLGetGreatestFactor(&fl), 1299827);
ck_assert_uint_eq(gaIFLGetProduct(&fl), n);
/**
* Attempt approximate factorization for 2196095973992233039, 16-smooth constraint.
* 2196095973992233039 is a large, highly non-smooth number, with three enormous
* factors. It is not 64-smooth, so code paths that attempt approximate
* factorization within the growth limits (.005%) are exercised.
*
* Expected PASS *relatively quickly*.
*/
n = 2196095973992233039ULL;
ck_assert_int_ne (gaIFactorize(n, n*1.00005, 16, &fl), 0);
ck_assert_uint_ge(gaIFLGetProduct(&fl), n);
ck_assert_uint_le(gaIFLGetProduct(&fl), n*1.00005);
/**
* Attempt exact factorization of 7438473388800000000, 5-smooth constraint.
* It is a large, 5-smooth number. This should exercise the 5-smooth
* factorization path.
*/
n = 7438473388800000000ULL;
ck_assert_int_ne (gaIFactorize(n, 0, 5, &fl), 0);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 2ULL), 14);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 3ULL), 19);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 5ULL), 8);
ck_assert_uint_eq(gaIFLGetGreatestFactor(&fl), 5);
ck_assert_uint_eq(gaIFLGetProduct(&fl), n);
/**
* Attempt approximate factorization of 7438473388799999997, 2-smooth constraint.
* It is a large, non-smooth number. This should exercise the optimal 2-smooth
* factorizer in spite of the available, unlimited slack.
*/
n = 7438473388799999997ULL;
ck_assert_int_ne (gaIFactorize(n, -1, 2, &fl), 0);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 2ULL), 63);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 3ULL), 0);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 5ULL), 0);
ck_assert_uint_eq(gaIFLGetGreatestFactor(&fl), 2);
ck_assert_uint_eq(gaIFLGetProduct(&fl), 9223372036854775808ULL);
/**
* Attempt approximate factorization of 7438473388799999997, 3-smooth constraint.
* It is a large, non-smooth number. This should exercise the optimal 3-smooth
* factorizer in spite of the available, unlimited slack.
*/
n = 7438473388799999997ULL;
ck_assert_int_ne (gaIFactorize(n, -1, 3, &fl), 0);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 2ULL), 31);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 3ULL), 20);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 5ULL), 0);
ck_assert_uint_eq(gaIFLGetGreatestFactor(&fl), 3);
ck_assert_uint_eq(gaIFLGetProduct(&fl), 7487812485248974848ULL);
/**
* Attempt approximate factorization of 7438473388799999997, 5-smooth constraint.
* It is a large, non-smooth number, but 3 integers above it is a 5-smooth
* integer, 7438473388800000000. This should exercise the optimal 5-smooth
* factorizer in spite of the available, unlimited slack.
*/
n = 7438473388799999997ULL;
ck_assert_int_ne (gaIFactorize(n, -1, 5, &fl), 0);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 2ULL), 14);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 3ULL), 19);
ck_assert_int_eq (gaIFLGetFactorPower(&fl, 5ULL), 8);
ck_assert_uint_eq(gaIFLGetGreatestFactor(&fl), 5);
ck_assert_uint_eq(gaIFLGetProduct(&fl), 7438473388800000000ULL);
/**
* Toughest challenge: Attempt very tight approximate factorization of
* 9876543210987654321 with .01% slack and 43-smooth constraint.
*
* This forces a bypass of the optimal 5-smooth factorizers and heavily
* exercises the nextI:, subfactorize:, primetest: and newX jumps and
* calculations.
*
* Expected PASS, "reasonably fast".
*/
n = 9876543210987654321ULL;
ck_assert_int_ne (gaIFactorize(n, n*1.0001, 43, &fl), 0);
ck_assert_uint_ge(gaIFLGetProduct(&fl), n);
ck_assert_uint_le(gaIFLGetProduct(&fl), n*1.0001);
ck_assert_uint_le(gaIFLGetGreatestFactor(&fl), 43);
}END_TEST
}END_TEST
START_TEST(test_scheduler){
/* We use here the CUDA limits of a CC 3.0 GPU as an example. */
uint64_t maxBTot = 1024, maxBInd[] = { 1024, 1024, 64},
maxGTot = 0xFFFFFFFF, maxGInd[] = {2147483647, 65535, 65535},
warpSize = 32;
int warpAxis;
uint64_t dims[3];
ga_factor_list factBS[3], factGS[3], factCS[3];
unsigned long long intbBS[3], intbGS[3], intbCS[3];
unsigned long long intaBS[3], intaGS[3], intaCS[3];
/**
* NOTE: If you want to view befores-and-afters of scheduling, #define PRINT
* to something non-0.
*/
#define PRINT 0
/**
*
* Testcase: (895,1147,923) job, warpSize on axis 0.
*
*/
{
warpAxis = 0;
dims[0] = 895;
dims[1] = 1141;
dims[2] = 923;
dims[warpAxis] = (dims[warpAxis]+warpSize-1) / warpSize;
/**
* Factorization job must be successful.
*/
ck_assert(gaIFactorize(warpAxis==0?warpSize:1, 0, maxBInd[0], factBS+0));
ck_assert(gaIFactorize(warpAxis==1?warpSize:1, 0, maxBInd[1], factBS+1));
ck_assert(gaIFactorize(warpAxis==2?warpSize:1, 0, maxBInd[2], factBS+2));
ck_assert(gaIFactorize( 1, 0, maxBInd[0], factGS+0));
ck_assert(gaIFactorize( 1, 0, maxBInd[1], factGS+1));
ck_assert(gaIFactorize( 1, 0, maxBInd[2], factGS+2));
ck_assert(gaIFactorize( dims[0], dims[0]*1.1, maxBInd[0], factCS+0));
ck_assert(gaIFactorize( dims[1], dims[1]*1.1, maxBInd[1], factCS+1));
ck_assert(gaIFactorize( dims[2], dims[2]*1.1, maxBInd[2], factCS+2));
intbBS[0] = gaIFLGetProduct(factBS+0);
intbBS[1] = gaIFLGetProduct(factBS+1);
intbBS[2] = gaIFLGetProduct(factBS+2);
intbGS[0] = gaIFLGetProduct(factGS+0);
intbGS[1] = gaIFLGetProduct(factGS+1);
intbGS[2] = gaIFLGetProduct(factGS+2);
intbCS[0] = gaIFLGetProduct(factCS+0);
intbCS[1] = gaIFLGetProduct(factCS+1);
intbCS[2] = gaIFLGetProduct(factCS+2);
/**
* Ensure that factorization only *increases* the size of the problem.
*/
ck_assert_uint_ge(intbCS[0], dims[0]);
ck_assert_uint_ge(intbCS[1], dims[1]);
ck_assert_uint_ge(intbCS[2], dims[2]);
/**
* Run scheduler.
*/
#if PRINT
printf("Before:\n");
printf("BS: (%6llu, %6llu, %6llu)\n", intbBS[0], intbBS[1], intbBS[2]);
printf("GS: (%6llu, %6llu, %6llu)\n", intbGS[0], intbGS[1], intbGS[2]);
printf("CS: (%6llu, %6llu, %6llu)\n", intbCS[0], intbCS[1], intbCS[2]);
#endif
gaIFLSchedule(3, maxBTot, maxBInd, maxGTot, maxGInd, factBS, factGS, factCS);
intaBS[0] = gaIFLGetProduct(factBS+0);
intaBS[1] = gaIFLGetProduct(factBS+1);
intaBS[2] = gaIFLGetProduct(factBS+2);
intaGS[0] = gaIFLGetProduct(factGS+0);
intaGS[1] = gaIFLGetProduct(factGS+1);
intaGS[2] = gaIFLGetProduct(factGS+2);
intaCS[0] = gaIFLGetProduct(factCS+0);
intaCS[1] = gaIFLGetProduct(factCS+1);
intaCS[2] = gaIFLGetProduct(factCS+2);
#if PRINT
printf("After:\n");
printf("BS: (%6llu, %6llu, %6llu)\n", intaBS[0], intaBS[1], intaBS[2]);
printf("GS: (%6llu, %6llu, %6llu)\n", intaGS[0], intaGS[1], intaGS[2]);
printf("CS: (%6llu, %6llu, %6llu)\n", intaCS[0], intaCS[1], intaCS[2]);
#endif
/**
* Scheduling is only about moving factors between block/grid/chunk factor
* lists. Therefore, the three dimensions must not have changed size.
*/
ck_assert_uint_eq(intbBS[0]*intbGS[0]*intbCS[0], intaBS[0]*intaGS[0]*intaCS[0]);
ck_assert_uint_eq(intbBS[1]*intbGS[1]*intbCS[1], intaBS[1]*intaGS[1]*intaCS[1]);
ck_assert_uint_eq(intbBS[2]*intbGS[2]*intbCS[2], intaBS[2]*intaGS[2]*intaCS[2]);
/**
* Verify that the individual limits and global limits on threads in a
* block and blocks in a grid are met.
*/
ck_assert_uint_le(intaBS[0], maxBInd[0]);
ck_assert_uint_le(intaBS[1], maxBInd[1]);
ck_assert_uint_le(intaBS[2], maxBInd[2]);
ck_assert_uint_le(intaGS[0], maxGInd[0]);
ck_assert_uint_le(intaGS[1], maxGInd[1]);
ck_assert_uint_le(intaGS[2], maxGInd[2]);
ck_assert_uint_le(intaBS[0]*intaBS[1]*intaBS[2], maxBTot);
ck_assert_uint_le(intaGS[0]*intaGS[1]*intaGS[2], maxGTot);
}
/**
*
* Testcase: (1,1,121632959) job, warpSize on axis 2.
*
*/
{
warpAxis = 2;
dims[0] = 1;
dims[1] = 1;
dims[2] = 121632959;
dims[warpAxis] = (dims[warpAxis]+warpSize-1) / warpSize;
/**
* Factorization job must be successful.
*/
ck_assert(gaIFactorize(warpAxis==0?warpSize:1, 0, maxBInd[0], factBS+0));
ck_assert(gaIFactorize(warpAxis==1?warpSize:1, 0, maxBInd[1], factBS+1));
ck_assert(gaIFactorize(warpAxis==2?warpSize:1, 0, maxBInd[2], factBS+2));
ck_assert(gaIFactorize( 1, 0, maxBInd[0], factGS+0));
ck_assert(gaIFactorize( 1, 0, maxBInd[1], factGS+1));
ck_assert(gaIFactorize( 1, 0, maxBInd[2], factGS+2));
ck_assert(gaIFactorize( dims[0], dims[0]*1.1, maxBInd[0], factCS+0));
ck_assert(gaIFactorize( dims[1], dims[1]*1.1, maxBInd[1], factCS+1));
ck_assert(gaIFactorize( dims[2], dims[2]*1.1, maxBInd[2], factCS+2));
intbBS[0] = gaIFLGetProduct(factBS+0);
intbBS[1] = gaIFLGetProduct(factBS+1);
intbBS[2] = gaIFLGetProduct(factBS+2);
intbGS[0] = gaIFLGetProduct(factGS+0);
intbGS[1] = gaIFLGetProduct(factGS+1);
intbGS[2] = gaIFLGetProduct(factGS+2);
intbCS[0] = gaIFLGetProduct(factCS+0);
intbCS[1] = gaIFLGetProduct(factCS+1);
intbCS[2] = gaIFLGetProduct(factCS+2);
/**
* Ensure that factorization only *increases* the size of the problem.
*/
ck_assert_uint_ge(intbCS[0], dims[0]);
ck_assert_uint_ge(intbCS[1], dims[1]);
ck_assert_uint_ge(intbCS[2], dims[2]);
/**
* Run scheduler.
*/
#if PRINT
printf("Before:\n");
printf("BS: (%6llu, %6llu, %6llu)\n", intbBS[0], intbBS[1], intbBS[2]);
printf("GS: (%6llu, %6llu, %6llu)\n", intbGS[0], intbGS[1], intbGS[2]);
printf("CS: (%6llu, %6llu, %6llu)\n", intbCS[0], intbCS[1], intbCS[2]);
#endif
gaIFLSchedule(3, maxBTot, maxBInd, maxGTot, maxGInd, factBS, factGS, factCS);
intaBS[0] = gaIFLGetProduct(factBS+0);
intaBS[1] = gaIFLGetProduct(factBS+1);
intaBS[2] = gaIFLGetProduct(factBS+2);
intaGS[0] = gaIFLGetProduct(factGS+0);
intaGS[1] = gaIFLGetProduct(factGS+1);
intaGS[2] = gaIFLGetProduct(factGS+2);
intaCS[0] = gaIFLGetProduct(factCS+0);
intaCS[1] = gaIFLGetProduct(factCS+1);
intaCS[2] = gaIFLGetProduct(factCS+2);
#if PRINT
printf("After:\n");
printf("BS: (%6llu, %6llu, %6llu)\n", intaBS[0], intaBS[1], intaBS[2]);
printf("GS: (%6llu, %6llu, %6llu)\n", intaGS[0], intaGS[1], intaGS[2]);
printf("CS: (%6llu, %6llu, %6llu)\n", intaCS[0], intaCS[1], intaCS[2]);
#endif
/**
* Scheduling is only about moving factors between block/grid/chunk factor
* lists. Therefore, the three dimensions must not have changed size.
*/
ck_assert_uint_eq(intbBS[0]*intbGS[0]*intbCS[0], intaBS[0]*intaGS[0]*intaCS[0]);
ck_assert_uint_eq(intbBS[1]*intbGS[1]*intbCS[1], intaBS[1]*intaGS[1]*intaCS[1]);
ck_assert_uint_eq(intbBS[2]*intbGS[2]*intbCS[2], intaBS[2]*intaGS[2]*intaCS[2]);
/**
* Verify that the individual limits and global limits on threads in a
* block and blocks in a grid are met.
*/
ck_assert_uint_le(intaBS[0], maxBInd[0]);
ck_assert_uint_le(intaBS[1], maxBInd[1]);
ck_assert_uint_le(intaBS[2], maxBInd[2]);
ck_assert_uint_le(intaGS[0], maxGInd[0]);
ck_assert_uint_le(intaGS[1], maxGInd[1]);
ck_assert_uint_le(intaGS[2], maxGInd[2]);
ck_assert_uint_le(intaBS[0]*intaBS[1]*intaBS[2], maxBTot);
ck_assert_uint_le(intaGS[0]*intaGS[1]*intaGS[2], maxGTot);
}
}END_TEST
