int main(int argc, char ** argv)
{
DnxRegistrar * reg;
iDnxRegistrar * ireg;
DnxNodeRequest * node;
verbose = argc > 1 ? 1 : 0;
CHECK_ZERO(dnxRegistrarCreate((DnxChannel*)17, 5, ®));
ireg = (iDnxRegistrar *)reg;
CHECK_TRUE(ireg->channel == (DnxChannel*)17);
CHECK_TRUE(ireg->rqueue != 0);
CHECK_TRUE(ireg->tid != 0);
while (passes < 4)
dnxCancelableSleep(10);
CHECK_ZERO(dnxGetNodeRequest(reg, &node));
CHECK_TRUE(node == test_req1);
dnxRegistrarDestroy(reg);
#ifdef DEBUG_HEAP
CHECK_ZERO(dnxCheckHeap());
#endif
return 0;
}
bool a11c(void)
{ bool ok = true;
// Test setup
int i, j, n_total = 10;
float *a = new float[n_total];
float *b = new float[n_total];
for(i = 0; i < n_total; i++)
a[i] = float(i);
// number of threads
int n_thread = NUMBER_THREADS;
// the threads
pthread_t thread[NUMBER_THREADS];
// arguments to start_routine
struct start_arg arg[NUMBER_THREADS];
// attr
pthread_attr_t attr;
CHECK_ZERO( pthread_attr_init( &attr ) );
CHECK_ZERO( pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE) );
//
// Break the work up into sub work for each thread
int n = n_total / n_thread;
arg[0].n = n;
arg[0].a = a;
arg[0].b = b;
for(j = 1; j < n_thread; j++)
{ arg[j].n = n + 1;
arg[j].a = arg[j-1].a + n - 1;
arg[j].b = arg[j-1].b + n - 1;
if( j == (n_thread - 1) )
arg[j].n = n_total - j * n + 1;
}
for(j = 0; j < n_thread; j++)
{ // inform each thread of which block it is working on
void* arg_vptr = static_cast<void*>( &arg[j] );
CHECK_ZERO( pthread_create(
&thread[j], &attr, start_routine, arg_vptr
) );
}
for(j = 0; j < n_thread; j++)
{ void* no_status = 0;
CHECK_ZERO( pthread_join(thread[j], &no_status) );
}
// check the result
float eps = 100. * std::numeric_limits<float>::epsilon();
for(i = 1; i < n ; i++)
ok &= std::fabs( (2. * b[i] - a[i] - a[i-1]) / b[i] ) <= eps;
delete [] a;
delete [] b;
return ok;
}
void ciMsaFluidSolver::fadeR() {
// I want the fluid to gradually fade out so the screen doesn't fill. the amount it fades out depends on how full it is, and how uniform (i.e. boring) the fluid is...
// float holdAmount = 1 - _avgDensity * _avgDensity * fadeSpeed; // this is how fast the density will decay depending on how full the screen currently is
float holdAmount = 1 - fadeSpeed;
_avgDensity = 0;
_avgSpeed = 0;
float totalDeviations = 0;
float currentDeviation;
float tmp_r;
// float uniformityMult = uniformity * 0.05f;
_avgSpeed = 0;
for (int i = _numCells-1; i >=0; --i) {
// clear old values
uvOld[i] = ci::Vec2f::zero();
rOld[i] = 0;
// gOld[i] = bOld[i] = 0;
// calc avg speed
_avgSpeed += uv[i].x * uv[i].x + uv[i].y * uv[i].y;
// calc avg density
tmp_r = ci::math<float>::min( 1.0f, r[i] );
// g[i] = MIN(1.0f, g[i]);
// b[i] = MIN(1.0f, b[i]);
// float density = MAX(r[i], MAX(g[i], b[i]));
_avgDensity += tmp_r; // add it up
// calc deviation (for uniformity)
currentDeviation = tmp_r - _avgDensity;
totalDeviations += currentDeviation * currentDeviation;
// fade out old
r[i] = tmp_r * holdAmount;
CHECK_ZERO(r[i]);
CHECK_ZERO(uv[i].x);
CHECK_ZERO(uv[i].y);
if(doVorticityConfinement) CHECK_ZERO(curl[i]);
}
_avgDensity *= _invNumCells;
// _avgSpeed *= _invNumCells;
// println("%.3f\n", _avgSpeed);
_uniformity = 1.0f / (1 + totalDeviations * _invNumCells); // 0: very wide distribution, 1: very uniform
}
int main(int argc, char *argv[]) {
int status;
int mode=0;
pthread_t midiinthread;
snd_rawmidi_t* midiin=NULL;
const char* portname="hw:1,0,0";// see alsarawportlist.c example program
if ((argc > 1) && (strncmp("hw:", argv[1], 3)==0)) {
portname=argv[1];
}
if ((status=snd_rawmidi_open(&midiin, NULL, portname, mode)) < 0) {
errormessage("Problem opening MIDI input: %s", snd_strerror(status));
exit(EXIT_FAILURE);
}
// type "man pthread_create" for more information about this function:
status=pthread_create(&midiinthread, NULL, midiinfunction, midiin);
if (status==-1) {
errormessage("Unable to create MIDI input thread.");
exit(EXIT_FAILURE);
}
CHECK_ZERO(sleep(60)); // do nothing for a while; thread does all the work.
snd_rawmidi_close(midiin);
midiin=NULL; // snd_rawmidi_close() does not clear invalid pointer,
printf("\n"); // so might be a good idea to erase it after closing.
return EXIT_SUCCESS;
}
void FluidSolver::fadeDensity() {
// I want the fluid to gradually fade out so the screen doesn't fill. the amount it fades out depends on how full it is, and how uniform (i.e. boring) the fluid is...
// float holdAmount = 1 - _avgDensity * _avgDensity * fadeSpeed; // this is how fast the density will decay depending on how full the screen currently is
float holdAmount = 1 - fadeSpeed;
_avgDensity = 0;
_avgSpeed = 0;
float totalDeviations = 0;
float currentDeviation;
float tmp;
_avgSpeed = 0;
for (int i = _numCells-1; i >=0; --i) {
// clear old values
uvOld[i].set(0, 0);// = ofVec2f::zero();
densityOld[i] = 0;
// calc avg speed
_avgSpeed += uv[i].x * uv[i].x + uv[i].y * uv[i].y;
// calc avg density
tmp = min( 1.0f, density[i]);
_avgDensity += tmp; // add it up
// calc deviation (for uniformity)
currentDeviation = tmp - _avgDensity;
totalDeviations += currentDeviation * currentDeviation;
// fade out old
density[i] = tmp * holdAmount;
CHECK_ZERO(density[i]);
CHECK_ZERO(uv[i].x);
CHECK_ZERO(uv[i].y);
if(doVorticityConfinement) CHECK_ZERO(curl[i]);
}
_avgDensity *= _invNumCells;
_avgSpeed *= _invNumCells;
// println("%.3f\n", _avgSpeed);
_uniformity = 1.0f / (1 + totalDeviations * _invNumCells); // 0: very wide distribution, 1: very uniform
}
int main(int argc,char** argv,char** envp) {
void* h=CHECK_NOT_NULL(dlopen("libadd.so", RTLD_NOW));
void* sym=CHECK_NOT_NULL(dlsym(h,"func"));
int (*f)(int, int);
f=((int(*)(int, int))sym);
int result=f(2,2);
printf("2+2 is %d\n",result);
CHECK_ZERO(dlclose(h));
return EXIT_SUCCESS;
}
int dnxPostResult(void * payload, unsigned long serial,
time_t start_time, unsigned delta, int early_timeout,
int res_code, char * res_data)
{
CHECK_TRUE(payload == &fakepayload);
CHECK_TRUE(start_time == 100);
CHECK_TRUE(early_timeout != 0);
CHECK_TRUE(res_code == 0);
CHECK_ZERO(memcmp(res_data, "(DNX: Service", 13));
return 0;
}
int main(int argc, char ** argv)
{
DnxTimer * timer;
iDnxTimer * itimer;
verbose = argc > 1? 1: 0;
// setup test harness
fakenode.xid.objType = DNX_OBJ_JOB;
fakenode.xid.objSerial = 1;
fakenode.xid.objSlot = 2;
fakenode.reqType = DNX_REQ_DEREGISTER;
fakenode.jobCap = 1;
fakenode.ttl = 2;
fakenode.expires = 3;
strcpy(fakenode.address, "fake address");
fakejob.state = DNX_JOB_INPROGRESS;
fakejob.xid.objType = DNX_OBJ_JOB;
fakejob.xid.objSerial = 1;
fakejob.xid.objSlot = 2;
fakejob.cmd = "fake command line";
fakejob.start_time = 100;
fakejob.timeout = 10;
fakejob.expires = fakejob.start_time + fakejob.timeout;
fakejob.payload = &fakepayload;
fakejob.pNode = &fakenode;
entered_dnxJobListExpire = 0;
// create a short timer and reference it as a concrete object for testing
CHECK_ZERO(dnxTimerCreate(&fakejoblist, 100, &timer));
itimer = (iDnxTimer *)timer;
// check internal state
CHECK_TRUE(itimer->joblist == &fakejoblist);
CHECK_TRUE(itimer->tid != 0);
CHECK_TRUE(itimer->sleepms == 100);
// wait for timer to have made one pass though timer thread loop
while (!entered_dnxJobListExpire)
dnxCancelableSleep(10);
// shut down
dnxTimerDestroy(timer);
return 0;
}
void RubyConfig::init()
{
// MemoryControl:
CHECK_NON_ZERO(MEM_BUS_CYCLE_MULTIPLIER);
CHECK_NON_ZERO(BANKS_PER_RANK);
CHECK_NON_ZERO(RANKS_PER_DIMM);
CHECK_NON_ZERO(DIMMS_PER_CHANNEL);
CHECK_NON_ZERO(BANK_QUEUE_SIZE);
CHECK_NON_ZERO(BANK_BUSY_TIME);
CHECK_NON_ZERO(MEM_CTL_LATENCY);
CHECK_NON_ZERO(REFRESH_PERIOD);
CHECK_NON_ZERO(BASIC_BUS_BUSY_TIME);
CHECK_POWER_OF_2(BANKS_PER_RANK);
CHECK_POWER_OF_2(RANKS_PER_DIMM);
CHECK_POWER_OF_2(DIMMS_PER_CHANNEL);
CHECK_NON_ZERO(g_MEMORY_SIZE_BYTES);
CHECK_NON_ZERO(g_DATA_BLOCK_BYTES);
CHECK_NON_ZERO(g_PAGE_SIZE_BYTES);
CHECK_NON_ZERO(g_NUM_PROCESSORS);
CHECK_NON_ZERO(g_PROCS_PER_CHIP);
if(g_NUM_SMT_THREADS == 0){ //defaults to single-threaded
g_NUM_SMT_THREADS = 1;
}
if (g_NUM_L2_BANKS == 0) { // defaults to number of ruby nodes
g_NUM_L2_BANKS = g_NUM_PROCESSORS;
}
if (g_NUM_MEMORIES == 0) { // defaults to number of ruby nodes
g_NUM_MEMORIES = g_NUM_PROCESSORS;
}
CHECK_ZERO(g_MEMORY_SIZE_BITS);
CHECK_ZERO(g_DATA_BLOCK_BITS);
CHECK_ZERO(g_PAGE_SIZE_BITS);
CHECK_ZERO(g_NUM_PROCESSORS_BITS);
CHECK_ZERO(g_NUM_CHIP_BITS);
CHECK_ZERO(g_NUM_L2_BANKS_BITS);
CHECK_ZERO(g_NUM_MEMORIES_BITS);
CHECK_ZERO(g_PROCS_PER_CHIP_BITS);
CHECK_ZERO(g_NUM_L2_BANKS_PER_CHIP);
CHECK_ZERO(g_NUM_L2_BANKS_PER_CHIP_BITS);
CHECK_ZERO(g_NUM_MEMORIES_BITS);
CHECK_ZERO(g_MEMORY_MODULE_BLOCKS);
CHECK_ZERO(g_MEMORY_MODULE_BITS);
CHECK_ZERO(g_NUM_MEMORIES_PER_CHIP);
CHECK_POWER_OF_2(g_MEMORY_SIZE_BYTES);
CHECK_POWER_OF_2(g_DATA_BLOCK_BYTES);
CHECK_POWER_OF_2(g_NUM_PROCESSORS);
CHECK_POWER_OF_2(g_NUM_L2_BANKS);
CHECK_POWER_OF_2(g_NUM_MEMORIES);
CHECK_POWER_OF_2(g_PROCS_PER_CHIP);
ASSERT(g_NUM_PROCESSORS >= g_PROCS_PER_CHIP); // obviously can't have less processors than procs/chip
g_NUM_CHIPS = g_NUM_PROCESSORS/g_PROCS_PER_CHIP;
ASSERT(g_NUM_L2_BANKS >= g_NUM_CHIPS); // cannot have a single L2cache across multiple chips
g_NUM_L2_BANKS_PER_CHIP = g_NUM_L2_BANKS/g_NUM_CHIPS;
ASSERT(L2_CACHE_NUM_SETS_BITS > log_int(g_NUM_L2_BANKS_PER_CHIP)); // cannot have less than one set per bank
L2_CACHE_NUM_SETS_BITS = L2_CACHE_NUM_SETS_BITS - log_int(g_NUM_L2_BANKS_PER_CHIP);
if (g_NUM_CHIPS > g_NUM_MEMORIES) {
g_NUM_MEMORIES_PER_CHIP = 1; // some chips have a memory, others don't
} else {
g_NUM_MEMORIES_PER_CHIP = g_NUM_MEMORIES/g_NUM_CHIPS;
}
g_NUM_CHIP_BITS = log_int(g_NUM_CHIPS);
g_MEMORY_SIZE_BITS = log_int(g_MEMORY_SIZE_BYTES);
g_DATA_BLOCK_BITS = log_int(g_DATA_BLOCK_BYTES);
g_PAGE_SIZE_BITS = log_int(g_PAGE_SIZE_BYTES);
g_NUM_PROCESSORS_BITS = log_int(g_NUM_PROCESSORS);
g_NUM_L2_BANKS_BITS = log_int(g_NUM_L2_BANKS);
g_NUM_L2_BANKS_PER_CHIP_BITS = log_int(g_NUM_L2_BANKS_PER_CHIP);
g_NUM_MEMORIES_BITS = log_int(g_NUM_MEMORIES);
g_PROCS_PER_CHIP_BITS = log_int(g_PROCS_PER_CHIP);
g_MEMORY_MODULE_BITS = g_MEMORY_SIZE_BITS - g_DATA_BLOCK_BITS - g_NUM_MEMORIES_BITS;
g_MEMORY_MODULE_BLOCKS = (int64(1) << g_MEMORY_MODULE_BITS);
if ((!Protocol::m_CMP) && (g_PROCS_PER_CHIP > 1)) {
ERROR_MSG("Non-CMP protocol should set g_PROCS_PER_CHIP to 1");
}
// Randomize the execution
srandom(g_RANDOM_SEED);
}
