void RAIDProcess::newMsg() {
RAIDProcessState *myState = (RAIDProcessState*) getState();
int ldelay = msgDelay();
IntVTime sendTime = dynamic_cast<const IntVTime&> (getSimulationTime());
RAIDRequest* newRequest = new RAIDRequest(sendTime, sendTime + ldelay + 1,
this, outputHandle);
newRequest->setSourceObject(getName());
newRequest->setSinkObject("");
newRequest->setStartCylinder(-1);
DiscreteUniform stripe(0, totalStripeSize, myState->getGen());
DiscreteUniform read(0, 1, myState->getGen());
DiscreteUniform size(1, maxStripeSize, myState->getGen());
newRequest->setStartStripe((int) stripe());
newRequest->setStartSector(-1);
newRequest->setSizeRead((int) size());
newRequest->setLogicalSector(-1);
if (newRequest->getSizeRead() == 0) {
cerr << "\n\n\n\nHold IT! sizeRead = 0\n\n\n\n\n" << "\n";
}
// If we try and read off the end of the array then move our starting
// location, so that we can still read the same amount of data.
if ((newRequest->getStartStripe() + newRequest->getSizeRead())
>= totalStripeSize) {
newRequest->setStartStripe(maxStripeSize - newRequest->getSizeRead());
}
newRequest->setBeginningOfStrype(newRequest->getStartStripe());
newRequest->setTokenNumber(myState->getNumRequests() + 1);
myState->setBeginningOfStrype(newRequest->getBeginningOfStrype());
myState->set_size(newRequest->getSizeRead());
newRequest->setSizeParity(0);
newRequest->setParityMsg(false);
if (read() == 0) {
newRequest->setRead(false);
// cout
// << "Write Started of size---------------------------------------------------------------------------------- "
// << myState->get_size() << endl;
myState->setRead(false);
} else {
newRequest->setRead(true);
myState->setRead(true);
// cout
// << "Read Started of size---------------------------------------------------------------------------------- "
// << myState->get_size() << endl;
}
myState->setDiskOperationPending(true);
myState->setBeginningOfStrype(newRequest->getStartStripe());
myState->setStrypeSize(newRequest->getSizeRead());
myState->setNumRequests(myState->getNumRequests() + 1);
getObjectHandle(outputName)->receiveEvent(newRequest);
} // End of newMsg()
// Get a sequence by its chunk id and id.
void HTKDataDeserializer::GetSequenceById(size_t chunkId, size_t id, vector<SequenceDataPtr>& r)
{
const auto& chunkDescription = m_chunks[chunkId];
size_t utteranceIndex = chunkDescription.GetUtteranceForChunkFrameIndex(id);
const UtteranceDescription* utterance = chunkDescription.GetUtterance(utteranceIndex);
auto utteranceFrames = chunkDescription.GetUtteranceFrames(utteranceIndex);
size_t frameIndex = id - utterance->GetStartFrameIndexInsideChunk();
// wrapper that allows m[j].size() and m[j][i] as required by augmentneighbors()
MatrixAsVectorOfVectors utteranceFramesWrapper(utteranceFrames);
size_t leftExtent = m_augmentationWindow.first;
size_t rightExtent = m_augmentationWindow.second;
// page in the needed range of frames
if (leftExtent == 0 && rightExtent == 0)
{
leftExtent = rightExtent = msra::dbn::augmentationextent(utteranceFramesWrapper[0].size(), m_dimension);
}
HTKSequenceDataPtr result = make_shared<HTKSequenceData>();
result->m_buffer.resize(m_dimension, 1);
const vector<char> noBoundaryFlags; // TODO: dummy, currently to boundaries supported.
msra::dbn::augmentneighbors(utteranceFramesWrapper, noBoundaryFlags, frameIndex, leftExtent, rightExtent, result->m_buffer, 0);
result->m_numberOfSamples = 1;
msra::dbn::matrixstripe stripe(result->m_buffer, 0, result->m_buffer.cols());
if (m_elementType == ElementType::tfloat)
{
result->m_data = &stripe(0, 0);
}
else
{
assert(m_elementType == ElementType::tdouble);
const size_t dimensions = stripe.rows();
double *doubleBuffer = new double[dimensions];
const float *floatBuffer = &stripe(0, 0);
for (size_t i = 0; i < dimensions; i++)
{
doubleBuffer[i] = floatBuffer[i];
}
result->m_data = doubleBuffer;
}
r.push_back(result);
}
void TexturedFeather::sampleColor(float lod)
{
m_stripe->create(resShaft() * m_vane[0].gridU() * 2 + 1, resBarb() + 1);
unsigned nu, nv;
computeLODGrid(lod, nu, nv);
stripe()->begin();
sampleColor(nu, nv, 0);
sampleColor(nu, nv, 1);
}
void operator()( const tbb::blocked_range<int>& r )
{
utils::Rect stripe( r.begin(), _roi.left, r.end()-1, _roi.right );
float Xc = 0.5f * (float)(_roi.right + _roi.left);
float Yc = 0.5f * (float)(_roi.bottom + _roi.top);
double Hl[PARAM_CNT][PARAM_CNT];
double bl[PARAM_CNT];
HESS_FUNC( Hl, bl, _I1, _wI2, stripe, _gradThresh, Xc, Yc, _sigma );
for( int i = 0; i < PARAM_CNT; i++ )
{
for( int j = 0; j < PARAM_CNT; j++ )
H[i][j] += Hl[i][j];
}
for(int i = 0; i < PARAM_CNT; i++)
b[i] += bl[i];
}
void *watch_temp()
{
int length, i = 0, wd;
int fd;
char buffer[BUF_LEN];
int wds[MAX_WTD]; //for the wds
int trigger[MAX_WTD]; //for the event->wd that trigger the current wds
String dirs[MAX_WTD]; //for the directory names that is trigger by the wds
int counter = 1;
/*Initialize inotify*/
fd = inotify_init();
if ( fd < 0 ) {
perror( "Couldn't initialize inotify" );
}
/*add watch to directory*/
wd = inotify_add_watch(fd, TEMP_LOC, IN_ALL_EVENTS);
wds[counter-1] = wd;
strcpy(dirs[counter-1], TEMP_LOC);
if (wd == -1){
syslog(LOG_INFO, "FileTransaction: Couldn't add watch to %s\n", TEMP_LOC);
} else {
syslog(LOG_INFO, "FileTransaction: WRITE :: Watching:: %s\n", TEMP_LOC);
}
/*do it forever*/
while(1){
//select(fd+1, &descriptors, NULL, NULL, &time_to_wait);
create_link();
i = 0;
length = read(fd, buffer, BUF_LEN);
if (length < 0){
perror("read");
}
while(i < length){
struct inotify_event *event = (struct inotify_event *) &buffer[i];
if (event->len){
if (event->mask & IN_CREATE){
if (event->mask & IN_ISDIR){
//printf("%s is created.\n", event->name);
String dir_to_watch = "";
String root = "";
String arr[MAXDEPTH];
int d;
//Initialize array....
for (d = 0; d < 30; d++){
strcpy(arr[d], "");
}
get_root(wds,trigger, dirs, counter,event->wd,arr);
for (d = 1; d < counter; d++){
if(strcmp(arr[d], "") != 0) {
strcat(root, arr[d]);
strcat(root, "/");
}
}
String x;
sprintf(x, "%s%s", root, event->name);
sprintf(dir_to_watch,"%s/%s%s/", TEMP_LOC, root, event->name);
wd = inotify_add_watch(fd, dir_to_watch, IN_ALL_EVENTS);
if (wd == -1){
} else {
syslog(LOG_INFO, "FileTransaction: WRITE := Watching := %s\n", dir_to_watch);
}
//printf("DIR_TO_WATCH := %s\n", dir_to_watch);
wds[counter] = wd;
trigger[counter] = event->wd;
strcpy(dirs[counter], event->name);
/***************CREATES in /mnt/CVFSFSTorage AND LINK DIRECTORY to SHare *********/
String dir = "", chmod = "", sors = "", dest = "";
sprintf(dir, "mkdir '%s/%s'", SHIT_STORAGE, event->name);
system(dir);
sprintf(chmod, "chmod 777 -R '%s/%s'", SHIT_STORAGE, event->name);
system(chmod);
sprintf(sors, "%s/%s", SHIT_STORAGE, event->name);
sprintf(dest, "%s/%s", SHARE_LOC, x);
symlink(sors,dest);
/******************************************************************************/
make_folder(x);
counter++;
}
}
if (event->mask & IN_CLOSE){
if (event->mask & IN_ISDIR){
} else {
String root = "";
String arr[MAXDEPTH];
int n = sizeof(wds) / sizeof(wds[0]);
int d, i, rooti;
//initialize the array...
for (d = 0; d < MAXDEPTH; d++){
strcpy(arr[d], "");
}
get_root(wds, trigger, dirs, counter, event->wd, arr);
for (d = 1; d < counter; d++){
if(strcmp(arr[d], "") != 0) {
strcat(root, arr[d]);
strcat(root, "/");
}
}
String filepath = "";
String filename = "";
sprintf(filename, "%s%s", root, event->name);
FILE *fp;
sprintf(filepath, "%s/%s%s", TEMP_LOC, root, event->name);
//syslog(LOG_INFO, "FileTransaction: FILEPATH := %s\n", filepath);
//syslog(LOG_INFO, "FileTransaction: hahahaa: filepath:%s\n\tfilename:%s", filepath, filename);
fp = fopen(filepath, "rb");
if (fp != NULL){
fseek(fp, 0L, SEEK_END);
long sz = ftell(fp);
rewind(fp);
//check if stripe file
if (sz > STRIPE_SIZE){
//before striping, check cache
printf("STRIPED: %s | SIZE : %ld bytes\n", event->name, sz);
//printf("%s will be striped.\n", event->name);
//printf("Inserting into CacheContent...\n");
update_cache_list(event->name, root);
//printf("Cache Count: %d\n", getCacheCount());
// if (getCacheCount() < MAX_CACHE_SIZE) { //max cache size is 10
printf("Cache Size: %d\n", getCacheCount());
printf("%s will be put to cache.\n", filename);
file_map_cache(filename, event->name);
//create_link_cache(filename);
// }
//stripe(event->n);
//refreshCache();
//printf("ROOT = %s\n", root);
//printf("FILEPATH := %s\n", filepath);
//printf("FILENAME := %s\n", filename);
stripe(root, filepath, filename);
//refreshCache();
} else {
syslog(LOG_INFO, "FileTransaction: Transferring %s to targets...\n", filename);
file_map(filepath, filename);
}
}
}
}
if (event->mask & IN_MOVED_TO){
if (event->mask & IN_ISDIR)
printf("The directory %s is transferring.\n", event->name);
else
printf("The file %s is transferring.\n", event->name);
}
i += EVENT_SIZE + event->len;
}
}
}
/* Clean up */
inotify_rm_watch(fd, wd);
close(fd);
}
static bool process(void)
{
fill(0);
if (pause("00 ", DELAY)) {
return false;
}
fill(0xff);
if (pause("ff ", DELAY)) {
return false;
}
fill(0x55);
if (pause("55 ", DELAY)) {
return false;
}
fill(0x44);
if (pause("44 ", DELAY)) {
return false;
}
fill(0xf7);
if (pause("f7 ", DELAY)) {
return false;
}
print_char('\n');
print("stripe(00) ");
stripe(0xff, 0x00);
if (pause("ff ", DELAY)) {
return false;
}
stripe(0x01, 0x00);
if (pause("01 ", DELAY)) {
return false;
}
print_char('\n');
print("stripe(ff) ");
stripe(0x00, 0xff);
if (pause("00 ", DELAY)) {
return false;
}
stripe(0xee, 0xff);
if (pause("7f ", DELAY)) {
return false;
}
print_char('\n');
display_image(0x00);
if (pause("image(00)", DELAY)) {
return false;
}
print_char('\n');
display_image(0xff);
if (pause("image(ff)", DELAY)) {
return false;
}
print_char('\n');
return true;
}
//----
bool update_trz_ppl_lambda( H3& dH, const utils::Matrix<float>& I1, const utils::Matrix<float>& wI2, float sigma, float gradThresh, const utils::Rect& roi )
{
static const int PARAM_CNT = 4;
class Worker
{
public:
Worker() {
memset( H, 0, PARAM_CNT*PARAM_CNT*sizeof(double) );
memset( b, 0, PARAM_CNT*sizeof(double) );
};
public: // state
double H[PARAM_CNT][PARAM_CNT];
double b[PARAM_CNT];
};
utils::Rect validRgn( roi.top+1, roi.left+1, roi.bottom-1, roi.right-1 ); // avoid problems with gradients
//Worker w( I1, wI2, sigma, gradThresh, validRgn );
//
Concurrency::combineable<Worker> workers;
Concurrency::parallel_for(validRgn.top, validRgn.bottom+1, [&](int r) {
utils::Rect stripe( r.begin(), validRgn.left, r.end()-1, validRgn.right );
float Xc = 0.5f * (float)(validRgn.right + validRgn.left);
float Yc = 0.5f * (float)(validRgn.bottom + validRgn.top);
double Hl[PARAM_CNT][PARAM_CNT];
double bl[PARAM_CNT];
sse::hessianTRZ( Hl, bl, I1, wI2, stripe, gradThresh, Xc, Yc, sigma );
for( int i = 0; i < PARAM_CNT; i++ )
{
for( int j = 0; j < PARAM_CNT; j++ )
init.H[i][j] += Hl[i][j];
}
for(int i = 0; i < PARAM_CNT; i++)
init.b[i] += bl[i];
});
[=](const tbb::blocked_range<int> &r, Worker init)->Worker {
utils::Rect stripe( r.begin(), validRgn.left, r.end()-1, validRgn.right );
float Xc = 0.5f * (float)(validRgn.right + validRgn.left);
float Yc = 0.5f * (float)(validRgn.bottom + validRgn.top);
double Hl[PARAM_CNT][PARAM_CNT];
double bl[PARAM_CNT];
sse::hessianTRZ( Hl, bl, I1, wI2, stripe, gradThresh, Xc, Yc, sigma );
for( int i = 0; i < PARAM_CNT; i++ )
{
for( int j = 0; j < PARAM_CNT; j++ )
init.H[i][j] += Hl[i][j];
}
for(int i = 0; i < PARAM_CNT; i++)
init.b[i] += bl[i];
return init;
},
[](const Worker &x, const Worker &y)->Worker {
Worker z;
for( int i = 0; i < PARAM_CNT; i++ )
{
for( int j = 0; j < PARAM_CNT; j++ )
z.H[i][j] = x.H[i][j] + y.H[i][j];
}
for(int i = 0; i < PARAM_CNT; i++)
z.b[i] = x.b[i] + y.b[i];
return z;
},
tbb::auto_partitioner());
#if 1
double dx[PARAM_CNT];
// solve and generate update
dH.zeros();
if( solve_ChD<double, PARAM_CNT>(dx, w.H, w.b) )
{
dH[0] = dx[0];
dH[1] = dx[1];
dH[3] = -dx[1];
dH[4] = dx[0];
dH[2] = dx[2];
dH[5] = dx[3];
return true;
}
#endif
return false; // ill conditioned hessian matrix (can not solve)
}
