void jobDone(char *line)
/* Handle job-done message - forward it to managing host. */
{
char *managingHost = nextWord(&line);
char *jobIdString = nextWord(&line);
// clearZombies();
if (jobIdString != NULL && line != NULL && line[0] != 0)
{
/* Remove job from list running list and put on recently finished list. */
struct job *job = findRunningJob(atoi(jobIdString));
if (job != NULL)
{
int status, err;
err = waitpid(job->pid, &status, 0);
if (err == -1 || !WIFEXITED(status) || WEXITSTATUS(status) != 0)
{
logDebug("paraNode sheparding %s pid %d status %d err %d errno %d",
jobIdString, job->pid, status, err, errno);
}
job->doneMessage = cloneString(line);
dlRemove(job->node);
if (dlCount(jobsFinished) >= 4*maxProcs)
{
struct dlNode *node = dlPopTail(jobsFinished);
struct job *oldJob = node->val;
jobFree(&oldJob);
}
dlAddHead(jobsFinished, job->node);
--busyProcs;
}
tellManagerJobIsDone(managingHost, jobIdString, line);
}
}
static void *carefulAlloc(size_t size)
/* Allocate extra memory for cookies and list node, and then
* return memory block. */
{
struct carefulMemBlock *cmb;
char *pEndCookie;
size_t newAlloced = size + carefulAlloced;
size_t aliSize;
if (newAlloced > carefulMaxToAlloc)
{
/* sprintLongWithCommas(maxAlloc, (long long)carefulMaxToAlloc);
sprintLongWithCommas(allocRequest, (long long)newAlloced);*/
errAbort("Allocated too much memory - more than %ld bytes (%ld)",
carefulMaxToAlloc, newAlloced);
}
carefulAlloced = newAlloced;
aliSize = ((size + sizeof(*cmb) + 4 + carefulAlignAdd)&carefulAlignMask);
cmb = carefulParent->alloc(aliSize);
cmb->size = size;
cmb->startCookie = cmbStartCookie;
pEndCookie = (char *)(cmb+1);
pEndCookie += size;
memcpy(pEndCookie, cmbEndCookie, sizeof(cmbEndCookie));
dlAddHead(cmbAllocedList, (struct dlNode *)cmb);
return (void *)(cmb+1);
}
struct dlNode *dlAddValHead(struct dlList *list, void *val)
/* Create a node containing val and add to head of list. */
{
struct dlNode *node = AllocA(struct dlNode);
node->val = val;
dlAddHead(list, node);
return node;
}
FILE *openFromCache(struct dlList *cache, struct seqFilePos *sfp)
/* Return open file handle via cache. The simple logic here
* depends on not more than N files being returned at once. */
{
static int maxCacheSize=16;
int cacheSize = 0;
struct dlNode *node;
struct cachedFile *cf;
int size;
/* First loop through trying to find it in cache, counting
* cache size as we go. */
for (node = cache->head; !dlEnd(node); node = node->next)
{
++cacheSize;
cf = node->val;
if (sameString(sfp->file, cf->name))
{
dlRemove(node);
dlAddHead(cache, node);
return cf->f;
}
}
/* If cache has reached max size free least recently used. */
if (cacheSize >= maxCacheSize)
{
node = dlPopTail(cache);
cf = node->val;
carefulClose(&cf->f);
freeMem(cf->name);
freeMem(cf);
freeMem(node);
}
/* Cache new file. */
AllocVar(cf);
cf->name = cloneString(sfp->file);
if (sfp->isTwoBit)
{
cf->f = (FILE *)twoBitOpen(sfp->file);
}
else if (sfp->isNib)
{
nibOpenVerify(sfp->file, &cf->f, &size);
if (cf->f == NULL)
errAbort("can't open nibfile %s\n",sfp->file);
sfp->pos = size;
}
else
cf->f = mustOpen(sfp->file, "rb");
dlAddValHead(cache, cf);
return cf->f;
}
FILE *openFromCache(struct dlList *cache, char *fileName)
/* Return open file handle via cache. The simple logic here
* depends on not more than N files being returned at once. */
{
static int maxCacheSize=32;
int cacheSize = 0;
struct dlNode *node;
struct cachedFile *cf;
/* First loop through trying to find it in cache, counting
* cache size as we go. */
for (node = cache->head; !dlEnd(node); node = node->next)
{
++cacheSize;
cf = node->val;
if (sameString(fileName, cf->name))
{
dlRemove(node);
dlAddHead(cache, node);
return cf->f;
}
}
/* If cache has reached max size free least recently used. */
if (cacheSize >= maxCacheSize)
{
node = dlPopTail(cache);
cf = node->val;
carefulClose(&cf->f);
freeMem(cf->name);
freeMem(cf);
freeMem(node);
}
/* Cache new file. */
AllocVar(cf);
cf->name = cloneString(fileName);
cf->f = mustOpen(fileName, "rb");
dlAddValHead(cache, cf);
return cf->f;
}
struct cachedSeqFile *openNibFromCache(struct dlList *cache, char *dirName, char *seqName)
/* Return open file handle via cache. */
{
static int maxCacheSize=32;
int cacheSize = 0;
struct dlNode *node;
struct cachedSeqFile *cn;
char fileName[512];
/* First loop through trying to find it in cache, counting
* cache size as we go. */
for (node = cache->head; !dlEnd(node); node = node->next)
{
++cacheSize;
cn = node->val;
if (sameString(seqName, cn->name))
{
dlRemove(node);
dlAddHead(cache, node);
return cn;
}
}
/* If cache has reached max size free least recently used. */
if (cacheSize >= maxCacheSize)
{
node = dlPopTail(cache);
cn = node->val;
cachedSeqFileFree(&cn);
freeMem(node);
}
/* Cache new file. */
AllocVar(cn);
cn->name = cloneString(seqName);
snprintf(fileName, sizeof(fileName), "%s/%s.nib", dirName, seqName);
cn->fileName = cloneString(fileName);
nibOpenVerify(fileName, &cn->f, &cn->size);
dlAddValHead(cache, cn);
return cn;
}
