void PixelProcessor::setFogColor(Color<float> fogColor)
{
// TODO: Compact into generic function
word fogR = (unsigned short)(65535 * fogColor.r);
word fogG = (unsigned short)(65535 * fogColor.g);
word fogB = (unsigned short)(65535 * fogColor.b);
fog.color4[0][0] = fogR;
fog.color4[0][1] = fogR;
fog.color4[0][2] = fogR;
fog.color4[0][3] = fogR;
fog.color4[1][0] = fogG;
fog.color4[1][1] = fogG;
fog.color4[1][2] = fogG;
fog.color4[1][3] = fogG;
fog.color4[2][0] = fogB;
fog.color4[2][1] = fogB;
fog.color4[2][2] = fogB;
fog.color4[2][3] = fogB;
fog.colorF[0] = replicate(fogColor.r);
fog.colorF[1] = replicate(fogColor.g);
fog.colorF[2] = replicate(fogColor.b);
}
void World::removeEntity(EntityRef ref) {
Entity *entity = refEntity(ref);
if(entity) {
m_entity_map.remove(ref.index());
replicate(ref.index());
}
}
void TouchDebug::mouseDown(const ci::app::MouseEvent& e) {
mReplicating = false;
if(e.isAltDown()) {
if(!mDropTouched){
mEngine.mouseTouchBegin(e, mTouchId + 2);
mDropTouched = true;
} else {
mEngine.mouseTouchEnded(e, mTouchId + 2);
mDropTouched = false;
}
} else if(e.isShiftDown()) {
mReplicating = true;
replicate(e, ds::ui::TouchInfo::Added);
} else if(e.isControlDown()){
if(mTwoTouching){
mTwoTouching = false;
} else {
mTwoTouching = true;
mTwoTouchDown = e.getPos();
}
} else if(mTwoTouching){
mEngine.mouseTouchBegin(e, mTouchId);
int deltaX = e.getPos().x - mTwoTouchDown.x;
int deltaY = e.getPos().y - mTwoTouchDown.y;
ci::app::MouseEvent mouseTwo = ci::app::MouseEvent(e.getWindow(), 0, mTwoTouchDown.x - deltaX, mTwoTouchDown.y - deltaY, e.getNativeModifiers(), e.getWheelIncrement(), e.getNativeModifiers());
mEngine.mouseTouchBegin(mouseTwo, mTouchId + 1);
} else {
mEngine.mouseTouchBegin(e, mTouchId);
}
}
void PixelProcessor::setFogRanges(float start, float end)
{
context->fogStart = start;
context->fogEnd = end;
if(start == end)
{
end += 0.001f; // Hack: ensure there is a small range
}
float fogScale = -1.0f / (end - start);
float fogOffset = end * -fogScale;
fog.scale = replicate(fogScale);
fog.offset = replicate(fogOffset);
}
const XMLCh *StringPool::getPooledString(const XMLCh *src)
{
if(src == 0) return 0;
if(*src == 0) return XMLUni::fgZeroLenString;
// strings longer than lengthThreshold bytes are not pooled, as it is not probable they can be recycled
const XMLCh* pszTmp = src + 1;
while(*pszTmp) ++pszTmp;
unsigned int length = (unsigned int)(pszTmp - src);
if(length > lengthThreshold) {
++_toobig;
return replicate(src, length);
}
unsigned int hashVal = hash(src, length);
unsigned int modHashVal = hashVal % _modulus;
const Bucket *bucket = _bucketList[modHashVal];
while(bucket) {
if(bucket->length == length &&
XPath2Utils::equals(bucket->value, src)) {
break;
}
bucket = bucket->next;
}
if(bucket) {
++_hits;
return bucket->value;
}
else {
++_misses;
if(_count >= (_modulus * 3 / 4)) {
resize();
modHashVal = hashVal % _modulus;
}
const XMLCh *result = replicate(src, length);
_bucketList[modHashVal] = new (_mm->allocate(sizeof(Bucket)))
Bucket(result, length, hashVal, _bucketList[modHashVal]);
++_count;
return result;
}
}
EntityRef World::addEntity(PEntity &&ptr, int index) {
DASSERT(ptr);
Entity *entity = ptr.get();
index = m_entity_map.add(std::move(ptr), index);
entity->hook(this, index);
replicate(index);
return entity->ref();
}
void TouchDebug::mouseUp(const ci::app::MouseEvent& e) {
if(mReplicating){
replicate(e, ds::ui::TouchInfo::Removed);
} else {
if(mTwoTouching){
mEngine.mouseTouchEnded(e, mTouchId + 1);
}
mEngine.mouseTouchEnded(e, mTouchId);
}
}
void User::addAnnualAllotment(qint32 year)
{
Deposit *deposit;
deposit = new Deposit;
deposit->setYear(year);
deposit->setAmount(annualAllotment);
deposits[deposits.size()] = deposit;
save();
emit replicate();
}
const XMLCh *StringPool::getPooledString(const XMLCh *src, unsigned int length)
{
if(src == 0) return 0;
if(length == 0) return XMLUni::fgZeroLenString;
if(length > lengthThreshold) {
++_toobig;
return replicate(src, length);
}
unsigned int hashVal = hash(src, length);
unsigned int modHashVal = hashVal % _modulus;
const Bucket *bucket = _bucketList[modHashVal];
while(bucket) {
if(bucket->length == length &&
equalsN(bucket->value, src, length)) {
break;
}
bucket = bucket->next;
}
if(bucket) {
++_hits;
return bucket->value;
}
else {
++_misses;
if(_count >= (_modulus * 3 / 4)) {
resize();
modHashVal = hashVal % _modulus;
}
const XMLCh *result = replicate(src, length);
_bucketList[modHashVal] = new (_mm->allocate(sizeof(Bucket)))
Bucket(result, length, hashVal, _bucketList[modHashVal]);
++_count;
return result;
}
}
// Replace first '\t' by filling up spaces until POS is reached
void tabto(string& s, int pos)
{
for (int i = 0; unsigned(i) < s.length() && i < pos; i++)
{
if (s[i] == '\t')
{
int offset = pos - i;
s.at(i, 1) = replicate(' ', offset);
return;
}
}
}
bool User::unlock(Client *client)
{
bool success = 0;
if (lockedBy == client) {
lockedBy = NULL;
version++;
save();
emit replicate();
success = 1;
}
return success;
}
int CDfuPlusHelper::doit()
{
const char* action = globals->queryProp("action");
if(action == NULL || *action == '\0')
throw MakeStringException(-1, "action is missing");
else if(stricmp(action, "spray") == 0)
return spray();
else if(stricmp(action, "replicate") == 0)
return replicate();
else if(stricmp(action, "despray") == 0)
return despray();
else if(stricmp(action, "copy") == 0)
return copy();
else if(stricmp(action, "copysuper") == 0)
return copysuper();
else if(stricmp(action, "remove") == 0)
return remove();
else if(stricmp(action, "rename") == 0)
return rename();
else if(stricmp(action, "list") == 0)
return list();
else if(stricmp(action, "recover") == 0)
return recover();
else if(stricmp(action, "addsuper") == 0)
return superfile("add");
else if(stricmp(action, "removesuper") == 0)
return superfile("remove");
else if(stricmp(action, "listsuper") == 0)
return superfile("list");
else if(stricmp(action, "savexml") == 0)
return savexml();
else if(stricmp(action, "add") == 0)
return add();
else if(stricmp(action, "status") == 0)
return status();
else if(stricmp(action, "abort") == 0)
return abort();
else if(stricmp(action, "resubmit") == 0)
return resubmit();
else if(stricmp(action, "monitor") == 0)
return monitor();
#ifdef DAFILESRV_LOCAL
else if(stricmp(action, "dafilesrv") == 0)
return rundafs();
#endif
else
throw MakeStringException(-1, "Unknown dfuplus action");
return 0;
}
User::User(Server *srv, QString fName)
{
server = srv;
fileName = fName;
lockedBy = NULL;
boss = NULL;
oldBoss = NULL;
region = NULL;
version = 0;
annualAllotment = 0;
updateManagersFlag = 0;
connect(this, SIGNAL(replicate()), this, SLOT(updateManagerChain()), Qt::QueuedConnection);
connect(this, SIGNAL(notify(Withdrawal *)), &server->emailNotifier, SLOT(notify(Withdrawal *)), Qt::QueuedConnection);
}
void TouchDebug::mouseDrag(const ci::app::MouseEvent& e) {
if(mReplicating){
replicate(e, ds::ui::TouchInfo::Moved);
} else if(mTwoTouching){
mEngine.mouseTouchMoved(e, mTouchId);
int deltaX = e.getPos().x - mTwoTouchDown.x;
int deltaY = e.getPos().y - mTwoTouchDown.y;
ci::app::MouseEvent mouseTwo = ci::app::MouseEvent(e.getWindow(), 0, mTwoTouchDown.x - deltaX, mTwoTouchDown.y - deltaY, e.getNativeModifiers(), e.getWheelIncrement(), e.getNativeModifiers());
mEngine.mouseTouchMoved(mouseTwo, mTouchId + 1);
} else {
mEngine.mouseTouchMoved(e, mTouchId);
}
}
void test_array_replicate()
{
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( replicate(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( replicate(Vector2f()) );
CALL_SUBTEST_3( replicate(Vector3d()) );
CALL_SUBTEST_4( replicate(Vector4f()) );
CALL_SUBTEST_5( replicate(VectorXf(16)) );
CALL_SUBTEST_6( replicate(VectorXcd(10)) );
}
}
void replicate(MPEncVector &vec,
const MPEncArray &ea,
const long c)
{
std::vector<std::thread> worker;
std::atomic<long> counter(0);
const long parts = vec.partsNum();
auto job = [&counter, &parts, &vec, &ea, &c]() {
long i;
while ((i = counter.fetch_add(1)) < parts) {
replicate(*ea.get(i), vec.get(i), c);
}
};
for (long wr = 0; wr < WORKER_NR; wr++) worker.push_back(std::thread(job));
for (auto &&wr : worker) wr.join();
}
void User::checkForExpiredRequests(quint32 today)
{
qint32 i;
bool update = 0;
for(i=0; i<withdrawals.size(); i++) {
if (withdrawals[i]->getState() == WDRL_REQUEST && withdrawals[i]->getStart() <= today) {
withdrawals[i]->setState(WDRL_REJECTED);
emit notify(withdrawals[i]);
update = 1;
}
}
if (update) {
save();
emit replicate();
}
}
uintptr_t
doOp(id_t id)
{
uintptr_t rc;
key_t k = id;
value_t v;
v = getValue(k);
retry:
if (v->v0.v) {
// hit
rc = v->v0.op(v->v1.arg);
} else {
// miss
if (replicate(id, v)) goto retry;
}
return rc;
}
void rice::p2p::replication::ReplicationImpl::deliver(::rice::p2p::commonapi::Id* id, ::rice::p2p::commonapi::Message* message)
{
if(npc(logger)->level <= ::rice::environment::logging::Logger::FINE)
npc(logger)->log(::java::lang::StringBuilder().append(u"COUNT: Replication "_j)->append(instance)
->append(u" received message "_j)
->append(static_cast< ::java::lang::Object* >(message))->toString());
if(dynamic_cast< ::rice::p2p::replication::messaging::RequestMessage* >(message) != nullptr) {
auto const rm = java_cast< ::rice::p2p::replication::messaging::RequestMessage* >(message);
auto continuation = new ::rice::Continuation_MultiContinuation(new ReplicationImpl_deliver_3(this, rm, u"Processing of RequestMessage"_j, environment), npc(npc(rm)->getRanges())->length);
for (auto i = int32_t(0); i < npc(npc(rm)->getRanges())->length; i++) {
auto const j = i;
npc(endpoint)->process(new ReplicationImpl_deliver_4(this, j, rm), npc(continuation)->getSubContinuation(i));
}
} else if(dynamic_cast< ::rice::p2p::replication::messaging::ResponseMessage* >(message) != nullptr) {
auto rm = java_cast< ::rice::p2p::replication::messaging::ResponseMessage* >(message);
for (auto i = int32_t(0); i < npc(npc(rm)->getIdSets())->length; i++) {
auto temp = npc(factory)->buildIdSet();
auto tempA = (*npc(rm)->getIdSets())[i];
for (auto j = int32_t(0); j < npc(tempA)->length; j++) {
npc(temp)->addId((*tempA)[j]);
}
auto fetch = npc(policy)->difference(npc(client)->scan((*npc(rm)->getRanges())[i]), temp, factory);
if(npc(logger)->level <= ::rice::environment::logging::Logger::FINE)
npc(logger)->log(::java::lang::StringBuilder().append(u"COUNT: Was told to fetch "_j)->append(npc(fetch)->numElements())
->append(u" in instance "_j)
->append(instance)->toString());
if(npc(fetch)->numElements() > 0)
npc(client)->fetch(fetch, npc(rm)->getSource());
}
} else if(dynamic_cast< ::rice::p2p::replication::messaging::ReminderMessage* >(message) != nullptr) {
replicate();
updateClient();
} else {
if(npc(logger)->level <= ::rice::environment::logging::Logger::WARNING)
npc(logger)->log(::java::lang::StringBuilder().append(u"Received unknown message "_j)->append(static_cast< ::java::lang::Object* >(message))
->append(u" - dropping on floor."_j)->toString());
}
}
void Door::think() {
const float2 dir = actualDir();
if(m_update_anim) {
replicate();
playSequence(m_proto.seq_ids[m_state]);
m_update_anim = false;
}
if(classId() == DoorClassId::sliding && m_state == DoorState::opened_in && currentTime() > m_close_time) {
FBox bbox = computeBBox(DoorState::closed);
if((bool)findAny(bbox + pos(), {Flags::entity | Flags::colliding, ref()})) {
m_close_time = currentTime() + 1.5;
}
else {
m_bbox = bbox;
m_state = DoorState::closing_in;
m_update_anim = true;
}
}
}
void Container::think() {
if(m_proto.is_always_opened)
return;
if(m_target_state != m_state) {
if(m_state == ContainerState::closed && m_target_state == ContainerState::opened) {
m_state = ContainerState::opening;
m_update_anim = true;
}
if(m_state == ContainerState::opened && m_target_state == ContainerState::closed) {
m_state = ContainerState::closing;
m_update_anim = true;
}
}
if(m_update_anim) {
replicate();
playSequence(m_proto.seq_ids[m_state]);
m_update_anim = false;
}
}
//*************************************************************************************************
//! Alternate way of specifying number of threads to support. This is the same as the number of
//! clones that will be available after replicating the original chain.
//*************************************************************************************************
void ossimImageChainMtAdaptor::setNumberOfThreads(ossim_uint32 num_threads)
{
if (m_numThreads == num_threads)
return;
// Determine number of cores/threads to set up:
if (num_threads > 0)
{
m_numThreads = num_threads;
}
else
{
// Look in ossim preferences if arg is provided above.
ossimString value = ossimPreferences::instance()->findPreference("ossim_threads");
if ( !value.empty() )
m_numThreads = value.toUInt32();
}
// If there is a valid original chain, we can perform the replication:
if (!m_chainContainers.empty())
replicate();
}
void Handle (DHT& dht, const Host&, const Packet& pckt)
{
Key k = pckt.GetArg<Key>(DHT_UNPUBLISH_KEY);
pf_log[W_DHT] << "Got Unpublish message for key " << k;
Data *data = pckt.GetArg<Data*>(DHT_UNPUBLISH_DATA);
pf_log[W_DHT] << "Data: " << data->GetStr();
try {
dht.GetStorage()->removeInfo(k, data);
}
catch(Storage::WrongDataType e) {
pf_log[W_DHT] << "Asked to remove wrong data type, abord.";
return;
}
/* Repeat unpublish on redondancy hosts */
Packet replicate(DHTRepeatUType, dht.GetMe());
replicate.SetArg(DHT_REPEAT_U_KEY, k);
replicate.SetArg(DHT_REPEAT_U_DATA, data);
dht.GetChimera()->SendToNeighbours(dht.REDONDANCY, replicate);
}
//*************************************************************************************************
//! Alternate way of specifying the original chain being adapted for multi-threading.
//*************************************************************************************************
void ossimImageChainMtAdaptor::setOriginalChain(ossimImageChain* original)
{
if (original == NULL)
return;
ossimImageSource* first_source = original->getFirstSource();
if (first_source == NULL)
return;
// Assign the adaptee and put it in the first position of the clones list:
m_adaptedChain = original;
m_clones.clear();
m_clones.push_back(first_source);
m_chainContainers.clear();
m_chainContainers.push_back(new ossimConnectableContainer);
m_adaptedChain->fillContainer(*m_chainContainers[0].get());
// If we know the number of threads, we can begin replicating:
if (m_numThreads > 1)
replicate();
}
std::vector<std::vector<T>> helper_carthesian_product_n_idxs
(std::size_t power, const std::vector<T>& xs)
{
static_assert(std::is_same<T, std::size_t>::value,
"T must be std::size_t");
typedef std::vector<T> Vec;
typedef std::vector<Vec> VecVec;
if (power == 0)
return VecVec();
auto go = [](const Vec& elems, const VecVec& acc)
{
VecVec result;
for (const T& x : elems)
{
for (const Vec& tail : acc)
{
result.push_back(append(Vec(1, x), tail));
}
}
return result;
};
return fold_right(go, VecVec(1), replicate(power, xs));
}
static void trace(const char *prefix, void *call_data)
{
DataLength* dl = (DataLength *) call_data;
string s(dl->data, dl->length);
bool s_ends_with_nl = false;
if (s.length() > 0 && s[s.length() - 1] == '\n')
{
s_ends_with_nl = true;
s = s.before(int(s.length() - 1));
}
s = quote(s);
string nl = "\\n\"\n";
nl += replicate(' ', strlen(prefix));
nl += "\"";
s.gsub("\\n", nl);
if (s_ends_with_nl)
s.at((int)(s.length() - 1), 0) = "\\n";
dddlog << prefix << s << '\n';
dddlog.flush();
}
bool COptMethodEP::optimise()
{
if (!initialize())
{
if (mpCallBack)
mpCallBack->finishItem(mhGenerations);
return false;
}
bool Continue = true;
// Initialize the population
Continue = creation();
// get the index of the fittest
mBestIndex = fittest();
if (mBestIndex != C_INVALID_INDEX)
{
// and store that value
mBestValue = mValue[mBestIndex];
Continue = mpOptProblem->setSolution(mBestValue, *mIndividual[mBestIndex]);
// We found a new best value lets report it.
mpParentTask->output(COutputInterface::DURING);
}
if (!Continue)
{
if (mpCallBack)
mpCallBack->finishItem(mhGenerations);
cleanup();
return true;
}
// iterate over Generations
for (mGeneration = 2; mGeneration <= mGenerations && Continue; mGeneration++)
{
// replicate the individuals
Continue = replicate();
// select the most fit
Continue = select();
// get the index of the fittest
mBestIndex = fittest();
if (mBestIndex != C_INVALID_INDEX &&
mValue[mBestIndex] < mBestValue)
{
mBestValue = mValue[mBestIndex];
Continue = mpOptProblem->setSolution(mBestValue, *mIndividual[mBestIndex]);
// We found a new best value lets report it.
//if (mpReport) mpReport->printBody();
mpParentTask->output(COutputInterface::DURING);
}
if (mpCallBack)
Continue = mpCallBack->progressItem(mhGenerations);
}
if (mpCallBack)
mpCallBack->finishItem(mhGenerations);
cleanup();
return true;
}
void* job_worker(void *arg) {
worker *w = (worker*)arg;
jobpool *jp = w->jp;
job *jptr;
uint8_t *jptrarg;
uint8_t status,jstate;
uint32_t jobid;
uint32_t op;
// syslog(LOG_NOTICE,"worker %p started (jobqueue: %p ; jptr:%p ; jptrarg:%p ; status:%p )",(void*)pthread_self(),jp->jobqueue,(void*)&jptr,(void*)&jptrarg,(void*)&status);
for (;;) {
queue_get(jp->jobqueue,&jobid,&op,&jptrarg,NULL);
// syslog(LOG_NOTICE,"job worker got job: %"PRIu32",%"PRIu32,jobid,op);
jptr = (job*)jptrarg;
zassert(pthread_mutex_lock(&(jp->jobslock)));
if (jobid==0 && op==0 && jptrarg==NULL) { // queue has been closed
job_close_worker(w);
zassert(pthread_mutex_unlock(&(jp->jobslock)));
return NULL;
}
jp->workers_avail--;
if (jp->workers_avail==0 && jp->workers_total<jp->workers_max) {
job_spawn_worker(jp);
}
if (jptr!=NULL) {
jstate=jptr->jstate;
if (jptr->jstate==JSTATE_ENABLED) {
jptr->jstate=JSTATE_INPROGRESS;
}
} else {
jstate=JSTATE_DISABLED;
}
zassert(pthread_mutex_unlock(&(jp->jobslock)));
switch (op) {
case OP_INVAL:
status = ERROR_EINVAL;
break;
/*
case OP_MAINSERV:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
mainserv_serve(*((int*)(jptr->args)));
status = STATUS_OK;
}
break;
*/
case OP_CHUNKOP:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = hdd_chunkop(opargs->chunkid,opargs->version,opargs->newversion,opargs->copychunkid,opargs->copyversion,opargs->length);
}
break;
/*
case OP_OPEN:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = hdd_open(ocargs->chunkid,ocargs->version);
}
break;
case OP_CLOSE:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = hdd_close(ocargs->chunkid);
}
break;
case OP_READ:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = hdd_read(rdargs->chunkid,rdargs->version,rdargs->blocknum,rdargs->buffer,rdargs->offset,rdargs->size,rdargs->crcbuff);
}
break;
case OP_WRITE:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = hdd_write(wrargs->chunkid,wrargs->version,wrargs->blocknum,wrargs->buffer,wrargs->offset,wrargs->size,wrargs->crcbuff);
}
break;
*/
case OP_SERV_READ:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = mainserv_read(rwargs->sock,rwargs->packet,rwargs->length);
}
break;
case OP_SERV_WRITE:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = mainserv_write(rwargs->sock,rwargs->packet,rwargs->length);
}
break;
case OP_REPLICATE:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = replicate(rpargs->chunkid,rpargs->version,rpargs->xormasks,rpargs->srccnt,((uint8_t*)(jptr->args))+sizeof(chunk_rp_args));
}
break;
case OP_GETBLOCKS:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = hdd_get_blocks(ijargs->chunkid,ijargs->version,ijargs->pointer);
}
break;
case OP_GETCHECKSUM:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = hdd_get_checksum(ijargs->chunkid,ijargs->version,ijargs->pointer);
}
break;
case OP_GETCHECKSUMTAB:
if (jstate==JSTATE_DISABLED) {
status = ERROR_NOTDONE;
} else {
status = hdd_get_checksum_tab(ijargs->chunkid,ijargs->version,ijargs->pointer);
}
break;
default: // OP_EXIT
// syslog(LOG_NOTICE,"worker %p exiting (jobqueue: %p)",(void*)pthread_self(),jp->jobqueue);
zassert(pthread_mutex_lock(&(jp->jobslock)));
job_close_worker(w);
zassert(pthread_mutex_unlock(&(jp->jobslock)));
return NULL;
}
job_send_status(jp,jobid,status);
zassert(pthread_mutex_lock(&(jp->jobslock)));
jp->workers_avail++;
if (jp->workers_avail > jp->workers_max_idle) {
job_close_worker(w);
zassert(pthread_mutex_unlock(&(jp->jobslock)));
return NULL;
}
zassert(pthread_mutex_unlock(&(jp->jobslock)));
}
}
INT main(INT argc, CHAR *argv[]) {
/********** MAIN PROGRAM *********************************
* Solve Laplace equation using Jacobi iteration method *
*
*********************************************************/
INT m = M_DEFAULT, mp, k, p, below, above;
long iter=MAXSTEPS;
REAL TOL=EPS_DEFAULT, del, gdel,start,finish,mytime;
CHAR line[80];
REAL **v, **vt, **vnew;
k = 0;
p= 1;
if(k == 0) {
fprintf(OUTPUT," Number of args in command line, argc :\n");
fprintf(OUTPUT," argc = %d :\n", argc);
if (argc >= 2)
fprintf(OUTPUT," arg[1]= %s :\n", argv[1]);
if (argc >= 3)
fprintf(OUTPUT," arg[2]= %s :\n", argv[2]);
if (argc >1){
m=atoi(argv[1]);
m=MAX_M;
}
if (argc >2 ) {
TOL= atof(argv[2]);
TOL=EPS;
}
fprintf(OUTPUT,"Size of interior points, m :\n");
fprintf(OUTPUT,"m = %d\n",m);
fprintf(OUTPUT,"Numerical accuracy, eps :\n");
fprintf(OUTPUT,"eps = %f\n",TOL);
fprintf(OUTPUT,"Number of processes, p :\n");
fprintf(OUTPUT,"p = %d\n",p);
start=-time(0);
}
mp = m/p;
v = allocate_2D(m, mp); /* allocate mem for 2D array */
vt = allocate_2D(mp, m);
vnew = allocate_2D(mp, m);
gdel = 1.0;
iter = 0;
bc(m, mp, v, k, p); /* initialize and define B.C. for v */
transpose(m, mp, v, vt); /* solve for vt */
/* driven by need of update_bc_2 */
replicate(mp, m, vt, vnew); /* vnew = vt */
REAL ro = 1.0 - pow (PI / (2 * (m + 1)), 2);
REAL w = 0;
while (gdel > TOL) { /* iterate until error below threshold */
iter++; /* increment iteration counter */
if(iter > MAXSTEPS) {
fprintf(OUTPUT,"Iteration terminated (exceeds %6d", MAXSTEPS);
fprintf(OUTPUT," )\n");
return (0); /* nonconvergent solution */
}
/* compute new solution according to the Jacobi scheme */
/*update_jacobi(mp, m, vt, vnew, &del); [> compute new vt <]*/
update_sor(mp, m, vt, vnew, &del, w);
update_w(&w, ro);
if (del > gdel)
gdel = del;
if( k == 0) {
fprintf(OUTPUT,"iter,del,gdel: %6d, %lf %lf\n",iter,del,gdel);
}
update_bc_2( mp, m, vt, k, below, above); /* update b.c. */
}
if (k == 0) {
finish=time(0);
mytime=start+finish;
fprintf(OUTPUT,"Stopped at iteration %d\n",iter);
fprintf(OUTPUT,"The maximum error = %f\n",gdel);
fprintf(OUTPUT,"Time = %f\n",mytime);
}
if (FILE_OUT) {
/* write v to file for use in MATLAB plots */
transpose(mp, m, vt, v);
write_file( m, mp, v, k, p );
}
free(v); free(vt); free(vnew); /* release allocated arrays */
return (0);
}
/*
* Returns the name of the server that will process the
* request for the client.
* The function will modify the file_list and server_list
*/
int select_backend(const char *fname)
{
int s_idx = -1;
int f_idx = -1;
int max_pair = 0; // stores max of free+request for this file
int max_free = 0; // The server's index that is most free
int i, j;
/* Traverse all servers and change server_list[].free
* Also find the highest free + request pair */
pthread_mutex_lock(&s_lock); // lock
max_free = 0;
for (i = 0; i < total_servers; i++) {
// Increment *freeness* of all other servers (max is MAX_FREE)
server_list[i].free =
(server_list[i].free < MAX_FREE)?server_list[i].free++:MAX_FREE;
// Find server that is most free
if (server_list[i].free > server_list[max_free].free)
max_free = i;
}
pthread_mutex_unlock(&s_lock); // unlock
/* Locate file in the file table */
pthread_mutex_lock(&f_lock); // lock
for (i = 0; i < MAX_FILES; i++) {
if (strcmp(file_list[i].name, fname) == 0) {
f_idx = i;
// Update the request field
file_list[f_idx].request++;
break;
}
}
// Traverse all servers having this file
for (j = 0; j < file_list[f_idx].tot_idx; j++) {
int tmp = 0;
// Calc max of free+request
if ((tmp = server_list[j].free +
file_list[f_idx].request) > max_pair) {
max_pair = tmp;
s_idx = j; // server to connect to
}
}
// See if this file needs to be replicated
if (file_list[f_idx].request >= REPL_THRESH) {
printf("***REPLICATE*****\n");
printf("File: %s, server from: %s, server to: %s\n",
file_list[f_idx].name, server_list[s_idx].name,
server_list[max_free].name);
if (replicate(f_idx, s_idx, max_free) < 0) {
// Ignore and continue
} else {
s_idx = max_free;
}
}
// Decrement the *freeness* of chosen server */
server_list[s_idx].free = (server_list[s_idx].free < 2)?0:
(server_list[s_idx].free - 2);
pthread_mutex_unlock(&f_lock); // unlock
printf("***SELECT_BACKEND***\n");
printf("\tRequested file: %s\n", fname);
printf("\tChosen server: %s, server_free: %d\n\tfile_req: %d\n",
server_list[s_idx].name, server_list[s_idx].free,
file_list[f_idx].request);
return(s_idx);
}
