/*!
* Free memory chunk
* \param mpool Memory pool to be used (if NULL default pool is used)
* \param chunk Chunk location (starting address)
* \return 0 if successful, -1 otherwise
*/
int ffs_free ( ffs_mpool_t *mpool, void *chunk_to_be_freed )
{
ffs_hdr_t *chunk, *before, *after;
ASSERT ( mpool && chunk_to_be_freed );
chunk = chunk_to_be_freed - sizeof (size_t);
MARK_FREE ( chunk ); /* mark it as free */
/* join with left? */
before = ( (void *) chunk ) - sizeof(size_t);
if ( CHECK_FREE ( before ) )
{
before = GET_HDR ( before );
ffs_remove_chunk ( mpool, before );
before->size += chunk->size; /* join */
chunk = before;
}
/* join with right? */
after = GET_AFTER ( chunk );
if ( CHECK_FREE ( after ) )
{
ffs_remove_chunk ( mpool, after );
chunk->size += after->size; /* join */
}
/* insert chunk in free list */
ffs_insert_chunk ( mpool, chunk );
/* set chunk tail */
CLONE_SIZE_TO_TAIL ( chunk );
return 0;
}
int DestroyFilterI(FILTER *fpPO)
{
VALIDATE(fpPO,FILTER_ID);
CHECK_FILE(fpPO->in);
CHECK_NFILE(fpPO->out,fpPO->outname);
CHECK_FREE(fpPO->mask);
CHECK_FREE(fpPO->blk_mask);
CHECK_WORDLIST(fpPO->wlis);
FREE(fpPO);
return(TRUE);
}
/*
* Nakon oslobađanja bloka radi se sortiranje liste tako da je na početku najmanji blok,
* a na kraju najveći blok.
* Blok se dodaje listu koja se:
* 1. blok spaja sa susjedima ukoliko su slobodni
* 2. sortira listu
*/
int bf_free ( bf_mpool_t *mpool, void *chunk_to_be_freed )
{
bf_hdr_t *chunk, *before, *after;
ASSERT ( mpool && chunk_to_be_freed );
chunk = chunk_to_be_freed - sizeof (size_t);
MARK_FREE ( chunk ); /* mark it as free */
/* join with left? */
before = ( (void *) chunk ) - sizeof(size_t);
if ( CHECK_FREE ( before ) )
{
before = GET_HDR ( before );
bf_remove_chunk ( mpool, before );
before->size += chunk->size; /* join */
chunk = before;
}
/* join with right? */
after = GET_AFTER ( chunk );
if ( CHECK_FREE ( after ) )
{
bf_remove_chunk ( mpool, after );
chunk->size += after->size; /* join */
}
/* insert chunk in free list */
//dodaje slobodan blok u listu i sortira
bf_insert_chunk ( mpool, chunk );
/* set chunk tail */
CLONE_SIZE_TO_TAIL ( chunk );
bf_hdr_t *iter;
iter = mpool->first;
print("Ispis slobodnih blokova:\n");
while( iter != NULL )
{
print("%d -> ", iter->size);
iter = iter->next;
}
print("\n");
return 0;
}
/************************************************************************
* Set random mask; Handles lines and blocks
*/
int SetRandFilterMaskingI(FILTER *filtPO, DOUB fracD)
{
int i, line;
char *tmaskPC;
LIMIT_NUM(fracD, 0.0, 1.0);
if( filtPO->l_blk > 1) {
tmaskPC = (char *)ALLOC(filtPO->n_block, sizeof(char));
MaskRandSubsetI(tmaskPC, filtPO->n_block, RNUM(fracD));
for(i=0; i<filtPO->n_block; i++)
{
line = filtPO->l_bof + (filtPO->l_blk * i);
BOG_CHECK(line >= filtPO->n_mask);
if(tmaskPC[i]) {
filtPO->mask[line] = 1;
}
}
CHECK_FREE(tmaskPC);
}
else {
MaskRandSubsetI(filtPO->mask, filtPO->n_mask, RNUM(fracD));
}
return(TRUE);
}
static int
l_esc_read (GPPort *p, unsigned char *c)
{
CHECK_NULL (p && c);
CHECK (gp_port_read (p, c, 1));
/*
* STX, ETX, ENQ, ACK, XOFF, XON, NACK, and ETB have to be masked by
* ESC. If we receive one of those (except ETX and ETB) without mask,
* we will not report an error, as it will be recovered automatically
* later. If we receive ETX or ETB, we reached the end of the packet
* and report a transmission error, so that the error can be
* recovered.
* If the camera sends us ESC (the mask), we will not count this byte
* and read a second one. This will be reverted and processed. It
* then must be one of STX, ETX, ENQ, ACK, XOFF, XON, NACK, ETB, or
* ESC. As before, if it is not one of those, we'll not report an
* error, as it will be recovered automatically later.
*/
/* The HP PhotoSmart does not escape every special code, only
* some and it gets confused if we do this checks. By relaxing
* these, it now downloads images etc.
*/
#ifndef LESSER_ESCAPES
if ((*c == STX ) || (*c == ETX) || (*c == ENQ ) || (*c == ACK) ||
(*c == XOFF) || (*c == XON) || (*c == NACK) || (*c == ETB)) {
#else /* LESSER_ESCAPES */
if ((*c == STX ) || (*c == XOFF) || (*c == XON)) {
#endif /* LESSER_ESCAPES */
GP_DEBUG ("Wrong ESC masking!");
if ((*c == ETX) || (*c == ETB))
return (GP_ERROR_CORRUPTED_DATA);
} else if (*c == ESC) {
CHECK (gp_port_read (p, c, 1));
*c = (~*c & 0xff);
if ((*c != STX ) && (*c != ETX ) && (*c != ENQ) &&
(*c != ACK ) && (*c != XOFF) && (*c != XON) &&
(*c != NACK) && (*c != ETB ) && (*c != ESC))
GP_DEBUG ("Wrong ESC masking!");
}
return (GP_OK);
}
static int
l_send (GPPort *p, GPContext *context, unsigned char *send_buffer,
unsigned int send_buffer_size)
{
unsigned char c;
unsigned char checksum;
/**********************************************************************/
/* sb: A pointer to the buffer that we will send. */
/* sbs: Its size. */
/**********************************************************************/
unsigned char *sb;
unsigned int sbs;
int i = 0;
CHECK_NULL (p && send_buffer);
/* We need to ping the camera first */
CHECK (l_ping (p, context));
/********************************************************/
/* We will write: */
/* - STX */
/* - low order byte of (send_buffer_size + 5) */
/* - high order byte of (send_buffer_size + 5) */
/* - 'send_buffer_size' bytes data plus ESC quotes */
/* - ETX */
/* - 1 byte for checksum plus ESC quotes */
/* */
/* The checksum covers all bytes after STX and before */
/* the checksum byte(s). */
/********************************************************/
sbs = send_buffer_size + 5;
sb = malloc (sizeof (char) * sbs);
sb[0] = STX;
sb[1] = send_buffer_size;
sb[2] = send_buffer_size >> 8;
checksum = sb[1];
checksum += sb[2];
for (i = 3; i < (sbs - 2); i++) {
checksum += *send_buffer;
if ( (*send_buffer == STX ) ||
(*send_buffer == ETX ) ||
(*send_buffer == ENQ ) ||
(*send_buffer == ACK ) ||
(*send_buffer == XOFF) ||
(*send_buffer == XON ) ||
(*send_buffer == NACK) ||
(*send_buffer == ETB ) ||
(*send_buffer == ESC )) {
sb = realloc (sb, ++sbs * sizeof (char));
sb[ i] = ESC;
sb[++i] = ~*send_buffer;
} else sb[ i] = *send_buffer;
send_buffer++;
}
sb[sbs - 2] = ETX;
checksum += ETX;
if ( (checksum == STX ) ||
(checksum == ETX ) ||
(checksum == ENQ ) ||
(checksum == ACK ) ||
(checksum == XOFF) ||
(checksum == XON ) ||
(checksum == NACK) ||
(checksum == ETB ) ||
(checksum == ESC )) {
sb = realloc (sb, ++sbs * sizeof (char));
sb[sbs - 2] = ESC;
sb[sbs - 1] = ~checksum;
} else sb[sbs - 1] = checksum;
for (i = 0; ; i++) {
/* Write data as above. */
CHECK_FREE (gp_port_write (p, sb, sbs), sb);
CHECK_FREE (gp_port_read (p, &c, 1), sb);
switch (c) {
case ACK:
/* ACK received. We can proceed. */
free (sb);
/* Write EOT. */
c = EOT;
CHECK (gp_port_write (p, &c, 1));
return (GP_OK);
case NACK:
/* NACK received. We'll try up to three times. */
if (i == 2) {
free (sb);
return (GP_ERROR_CORRUPTED_DATA);
} else break;
default:
/* Should not happen. */
return (GP_ERROR_CORRUPTED_DATA);
}
}
}
/**************************************************************************
* Rank correlation coefficient
* ALLOCATES AND FREES TEMP ARRAYS HERE
*/
DOUB RankCorD(void *aPO, void *bPO, int n, int ct)
{
int i, *iPI,*jPI;
REAL *iPR,*jPR;
DOUB rD,*iPD,*jPD;
DOUB *rank1PD,*rank2PD;
SCOREC *sc1PO, *sc2PO;
DB_STAT DB_PrI(">> RankCorD, n=%d, ct=%d\n",n,ct);
/***
* Attempt to allocate arrays
*/
sc1PO = CreateScorecsPO(n);
sc2PO = CreateScorecsPO(n);
rank1PD = (DOUB *)ALLOC(n,sizeof(DOUB));
rank2PD = (DOUB *)ALLOC(n,sizeof(DOUB));
if( (!sc1PO) || (!sc1PO) || (!rank1PD) || (!rank2PD) )
{
printf("Problem allocating temp space for rank correlations!\n");
CHECK_FREE(sc1PO); CHECK_FREE(sc2PO);
CHECK_FREE(rank1PD); CHECK_FREE(rank2PD);
return(-TOO_BIG_R);
}
/***
* Copy values from passed arrays SCORECs for sorting
*/
switch(ct)
{
case IS_INT:
iPI = (int *)aPO;
jPI = (int *)bPO;
for(i=0;i<n;i++)
{
sc1PO[i].sc = DNUM(iPI[i]);
sc2PO[i].sc = DNUM(jPI[i]);
}
break;
case IS_REAL:
iPR = (REAL *)aPO;
jPR = (REAL *)bPO;
for(i=0;i<n;i++)
{
sc1PO[i].sc = DNUM(iPR[i]);
sc2PO[i].sc = DNUM(jPR[i]);
}
break;
case IS_DOUB:
iPD = (DOUB *)aPO;
jPD = (DOUB *)bPO;
for(i=0;i<n;i++)
{
sc1PO[i].sc = iPD[i];
sc2PO[i].sc = jPD[i];
}
break;
default:
CHECK_FREE(sc1PO); CHECK_FREE(sc2PO);
CHECK_FREE(rank1PD); CHECK_FREE(rank2PD);
printf("Bogus ct code=%d\n",ct);
ERR("RankCorD","Bogus ct code");
return(-TOO_BIG_R);
}
/***
* Sort arrays and get rank arrays
*/
SortScorecVals(sc1PO,n,SORT_ASCEND);
SortScorecVals(sc2PO,n,SORT_ASCEND);
FillScorecRankArrayI(sc1PO,n,rank1PD);
FillScorecRankArrayI(sc2PO,n,rank2PD);
/***
* Now get normal coorelation on rank arrays
*/
rD = PearsonsCorD(rank1PD,rank2PD,n,IS_DOUB);
/***
* Clean up and bail
*/
CHECK_FREE(sc1PO); CHECK_FREE(sc2PO);
CHECK_FREE(rank1PD); CHECK_FREE(rank2PD);
return(rD);
}
/* open communication with mainframe under logical number 'id',
do all necessary initialization and start thread */
int
sy1527Start(unsigned id_nowused, char *ip_address)
{
int id; ///my:
char arg[30], userName[20], passwd[30], name[MAX_CAEN_NAME];
int link, ret;
pthread_mutex_lock(&global_mutex);
/* do global initialization on first call */
if(nmainframes == -1) sy1527Init();
nmainframes++;///my:
///id=nmainframes-1;///my:
///if((id+1)>nmainframes)nmainframes=id+1;
id=id_nowused;///nmainframes-1;///my:
printf("++++++++++++++++++++++++++++++++++++++++++++++++ nmainframes=%d id=%d\n", nmainframes, id);
/* lock global mutex to prevent other mainframes to be started
until we are done with this one */
/// my: move upward - pthread_mutex_lock(&global_mutex); otherwise many sy1527Init() are possible
if(nmainframes >= MAX_HVPS)
{
printf("ERROR: no more empty slots\n");
pthread_mutex_unlock(&global_mutex);
return(CAENHV_SYSERR);
}
CHECK_ID(id);
CHECK_FREE(id);
/// my: sprintf(name,"sy1527_%03d",id);
sprintf(name, CRATE_LABEL, id); /// my:
printf("System Name set as >%s<\n",name);
strcpy(arg,ip_address);
printf("TCP/IP address set as >%s<\n",arg);
link = LINKTYPE_TCPIP;
/*
strcpy(userName, "user");
strcpy(passwd, "user");
*/
strcpy(userName, "admin");
strcpy(passwd, "admin");
ret = CAENHVInitSystem(name, link, arg, userName, passwd);
printf("my: id_index=%d id=%d name=%s", id, ret, name );
printf("\nCAENHVInitSystem error: %s (num. %d)\n\n", CAENHVGetError(name),ret);
if(ret == CAENHV_OK)
{
if(strlen(ip_address)>=MAX_CAEN_NAME) {
printf("too long mainfraime IP: exits now\n"); /// my:
exit(1);
}
strcpy(Measure[id].IPADDR,ip_address); /// my:
Measure[id].id = ret;
strcpy(Measure[id].name, name);
Demand[id].id = ret;
strcpy(Demand[id].name, name);
}
else
{
printf("\n CAENHVInitSystem returned %d\n\n",ret);
pthread_mutex_unlock(&global_mutex);
return(CAENHV_SYSERR);
}
/* init mainframe mutex */
pthread_mutex_init(&mainframe_mutex[id], &mattr);
/* start thread */
stat[id].threadid = id;
force_exit[id] = 0;
if(pthread_create(&idth[id],NULL,sy1527MainframeThread,(void *)&stat[id])!=0)
{
printf("ERROR: pthread_create(0x%08lx[%d],...) failure\n",idth[id],id);
pthread_mutex_unlock(&global_mutex);
return(CAENHV_SYSERR);
}
else
{
printf("INFO: pthread_create(0x%08lx[%d],...) done\n",idth[id],id);
}
/* register mainframe */
mainframes[nmainframes-1] = id; /// my: removed nmainframes++
///mainframes[id] = id;
printf("====================== 111111111111\n");
/* get mainframe map */
sy1527GetMap(id);
printf("====================== 222222222222\n");
pthread_mutex_unlock(&global_mutex);
return(CAENHV_OK);
}
/* open communication with mainframe under logical number 'id',
do all necessary initialization and start thread */
int
sy527Start(unsigned id, char *ip_address)
{
char arg[30], userName[20], passwd[30], name[MAX_NAME];
int link, ret;
printf("123\n");fflush(stdout);
/* do global initialization on first call */
if(nmainframes == -1) sy527Init();
printf("456\n");fflush(stdout);
/* lock global mutex to prevent other mainframes to be started
until we are done with this one */
LOCK_GLOBAL;
if(nmainframes >= MAX_HVPS)
{
printf("ERROR: no more empty slots\n");
UNLOCK_GLOBAL;
return(CAENHV_SYSERR);
}
CHECK_ID(id);
CHECK_FREE(id);
sprintf(name,"sy527_%03d",id);
printf("System Name set as >%s<\n",name);
/*strcpy(arg,ip_address); for sy1527*/
/*printf("TCP/IP address set as >%s<\n",arg);*/
strcpy(arg,"sy527_0x100000_9");
/*link = LINKTYPE_TCPIP; for sy1527*/
link = LINKTYPE_CAENET;
strcpy(userName, "user");
strcpy(passwd, "user");
ret = CAENHVInitSystem(name, link, arg, userName, passwd);
printf("\nCAENHVInitSystem: %s (num. %d)\n\n", CAENHVGetError(name),ret);
if(ret == CAENHV_OK)
{
Measure[id]->id = ret;
strcpy(Measure[id]->name, name);
Demand[id]->id = ret;
strcpy(Demand[id]->name, name);
}
else
{
printf("\n CAENHVInitSystem returned %d\n\n",ret);
UNLOCK_GLOBAL;
return(CAENHV_SYSERR);
}
#ifndef vxWorks
/* init mainframe mutex */
pthread_mutex_init(&mainframe_mutex[id], &mattr);
#else
mainframe_mutex[id] = semBCreate(SEM_Q_FIFO, SEM_FULL);
if(mainframe_mutex[id] == NULL)
{
printf("ERROR: could not allocate 'mainframe_mutex' semaphore\n");
return(0);
}
#endif
/* start thread */
stat[id].threadid = id;
force_exit[id] = 0;
#ifdef vxWorks
{
int iTaskStat;
iTaskStat = taskSpawn("SY527THRD", 150, 0, 800000, sy527Thread,
&stat[id], 0, 0,0,0,0,0,0,0,0);
printf("taskSpawn(\"SY527THRD\") returns %d\n",iTaskStat);
if(iTaskStat == ERROR)
{
perror("taskSpawn");
UNLOCK_GLOBAL;
}
}
#else
if(pthread_create(&idth[id],NULL,sy527Thread,(void *)&stat[id])!=0)
{
printf("ERROR: pthread_create(0x%08lx[%d],...) failure\n",idth[id],id);
UNLOCK_GLOBAL;
return(CAENHV_SYSERR);
}
else
{
printf("INFO: pthread_create(0x%08lx[%d],...) done\n",idth[id],id);
}
#endif
/* register mainframe */
mainframes[nmainframes++] = id;
/* get mainframe map */
sy527GetMap(id);
UNLOCK_GLOBAL;
return(CAENHV_OK);
}
