int DmaManager_reference(DmaManagerPrivate *priv, int fd)
{
int id = 0;
int rc = 0;
pthread_mutex_lock(&dma_mutex);
initPortalMemory();
MMURequest_idRequest(priv->sglDevice, (SpecialTypeForSendingFd)fd);
if (priv->poll) {
int rc = priv->poll(priv->shared_mmu_indication, &priv->sglId);
fprintf(stderr, "[%s:%d] return after idrequest %d %d\n", __FUNCTION__, __LINE__, rc, priv->sglId);
}
else
sem_wait(&priv->sglIdSem);
id = priv->sglId;
#if !defined(SIMULATION) && !defined(__KERNEL__)
#ifdef ZYNQ
PortalSendFd sendFd;
sendFd.fd = fd;
sendFd.id = id;
rc = ioctl(priv->sglDevice->fpga_fd, PORTAL_SEND_FD, &sendFd);
#else
tSendFd sendFd;
sendFd.fd = fd;
sendFd.id = id;
rc = ioctl(priv->sglDevice->fpga_fd, PCIE_SEND_FD, &sendFd);
#endif
if (!rc) {
if (priv->poll) {
uint32_t ret;
int rc = priv->poll(priv->shared_mmu_indication, &ret);
fprintf(stderr, "[%s:%d] return after ioctl %d %d\n", __FUNCTION__, __LINE__, rc, ret);
}
else
sem_wait(&priv->confSem);
}
rc = id;
#else // defined(SIMULATION) || defined(__KERNEL__)
rc = send_fd_to_portal(priv->sglDevice, fd, id, global_pa_fd);
if (rc >= 0) {
//PORTAL_PRINTF("%s:%d sem_wait\n", __FUNCTION__, __LINE__);
if (priv->poll) {
uint32_t ret;
int rc = priv->poll(priv->shared_mmu_indication, &ret);
fprintf(stderr, "[%s:%d] return after sendfd %d %d\n", __FUNCTION__, __LINE__, rc, ret);
}
else
sem_wait(&priv->confSem);
}
#endif // defined(SIMULATION) || defined(__KERNEL__)
pthread_mutex_unlock(&dma_mutex);
return rc;
}
int main(int argc, const char **argv)
{
fprintf(stderr, "Main::%s %s\n", __DATE__, __TIME__);
DmaManager *hostDma = platformInit();
MMURequestProxy *nandsimMMU = new MMURequestProxy(IfcNames_NandMMURequestS2H);
DmaManager *nandsimDma = new DmaManager(nandsimMMU);
MMUIndicationNAND nandsimMMUIndication(nandsimDma,IfcNames_NandMMUIndicationH2S);
StrstrRequestProxy *strstrRequest = new StrstrRequestProxy(IfcNames_AlgoRequestS2H);
StrstrIndication *strstrIndication = new StrstrIndication(IfcNames_AlgoIndicationH2S);
//MemServerIndicationNAND nandsimMemServerIndication(IfcNames_NandMemServerIndication);
fprintf(stderr, "Main::allocating memory...\n");
// allocate memory for strstr data
int needleAlloc = portalAlloc(numBytes, 0);
int mpNextAlloc = portalAlloc(numBytes, 0);
int ref_needleAlloc = hostDma->reference(needleAlloc);
int ref_mpNextAlloc = hostDma->reference(mpNextAlloc);
fprintf(stderr, "%08x %08x\n", ref_needleAlloc, ref_mpNextAlloc);
char *needle = (char *)portalMmap(needleAlloc, numBytes);
int *mpNext = (int *)portalMmap(mpNextAlloc, numBytes);
const char *needle_text = "ababab";
int needle_len = strlen(needle_text);
strncpy(needle, needle_text, needle_len);
compute_MP_next(needle, mpNext, needle_len);
// fprintf(stderr, "mpNext=[");
// for(int i= 0; i <= needle_len; i++)
// fprintf(stderr, "%d ", mpNext[i]);
// fprintf(stderr, "]\nneedle=[");
// for(int i= 0; i < needle_len; i++)
// fprintf(stderr, "%d ", needle[i]);
// fprintf(stderr, "]\n");
portalCacheFlush(needleAlloc, needle, numBytes, 1);
portalCacheFlush(mpNextAlloc, mpNext, numBytes, 1);
fprintf(stderr, "Main::flush and invalidate complete\n");
fprintf(stderr, "Main::waiting to connect to nandsim_exe\n");
wait_for_connect_nandsim_exe();
fprintf(stderr, "Main::connected to nandsim_exe\n");
// base of haystack in "flash" memory
// this is read from nandsim_exe, but could also come from kernel driver
int haystack_base = read_from_nandsim_exe();
int haystack_len = read_from_nandsim_exe();
fprintf(stderr, "haystack_base=%d haystack_len=%d\n", haystack_base, haystack_len);
// request the next sglist identifier from the sglistMMU hardware module
// which is used by the mem server accessing flash memory.
int id = 0;
MMURequest_idRequest(nandsimDma->priv.sglDevice, 0);
sem_wait(&nandsimDma->priv.sglIdSem);
id = nandsimDma->priv.sglId;
// pairs of ('offset','size') pointing to space in nandsim memory
// this is unsafe. To do it properly, we should get this list from
// nandsim_exe or from the kernel driver. This code here might overrun
// the backing store allocated by nandsim_exe.
RegionRef region[] = {{0, 0x100000}, {0x100000, 0x100000}};
printf("[%s:%d]\n", __FUNCTION__, __LINE__);
int ref_haystackInNandMemory = send_reference_to_portal(nandsimDma->priv.sglDevice, sizeof(region)/sizeof(region[0]), region, id);
sem_wait(&(nandsimDma->priv.confSem));
fprintf(stderr, "%08x\n", ref_haystackInNandMemory);
// at this point, ref_needleAlloc and ref_mpNextAlloc are valid sgListIds for use by
// the host memory dma hardware, and ref_haystackInNandMemory is a valid sgListId for
// use by the nandsim dma hardware
fprintf(stderr, "about to setup device %d %d\n", ref_needleAlloc, ref_mpNextAlloc);
strstrRequest->setup(ref_needleAlloc, ref_mpNextAlloc, needle_len);
fprintf(stderr, "about to invoke search %d\n", ref_haystackInNandMemory);
strstrRequest->search(ref_haystackInNandMemory, haystack_len);
strstrIndication->wait();
fprintf(stderr, "algo1_nandsim: Done %d\n", (strstrIndication->match_cnt==3));
sleep(2);
exit(!(strstrIndication->match_cnt==3));
}
int main(int argc, const char **argv)
{
fprintf(stderr, "Main::%s %s\n", __DATE__, __TIME__);
MMURequestProxy *hostMMURequest = new MMURequestProxy(IfcNames_AlgoMMURequest);
DmaManager *hostDma = new DmaManager(hostMMURequest);
MMUIndication *hostMMUIndication = new MMUIndication(hostDma, IfcNames_AlgoMMUIndication);
MMURequestProxy *nandsimMMURequest = new MMURequestProxy(IfcNames_NandsimMMU0Request);
DmaManager *nandsimDma = new DmaManager(nandsimMMURequest);
MMUIndication *nandsimMMUIndication = new MMUIndication(nandsimDma,IfcNames_NandsimMMU0Indication);
RegexpRequestProxy *device = new RegexpRequestProxy(IfcNames_AlgoRequest);
RegexpIndication *deviceIndication = new RegexpIndication(IfcNames_AlgoIndication);
MemServerIndication *hostMemServerIndication = new MemServerIndication(IfcNames_HostMemServerIndication);
MemServerIndication *nandsimMemServerIndication = new MemServerIndication(IfcNames_NandsimMemServer0Indication);
haystack_dma = hostDma;
haystack_mmu = hostMMURequest;
regexp = device;
portalExec_start();
fprintf(stderr, "Main::allocating memory...\n");
// this is hard-coded into the REParser.java
assert(32 == MAX_NUM_STATES);
assert(32 == MAX_NUM_CHARS);
////////////////////////////////////////////////////////////////////
//
fprintf(stderr, "Main::waiting to connect to nandsim_exe\n");
wait_for_connect_nandsim_exe();
fprintf(stderr, "Main::connected to nandsim_exe\n");
// base of haystack in "flash" memory
// this is read from nandsim_exe, but could also come from kernel driver
int haystack_base = read_from_nandsim_exe();
int haystack_len = read_from_nandsim_exe();
// request the next sglist identifier from the sglistMMU hardware module
// which is used by the mem server accessing flash memory.
int id = 0;
MMURequest_idRequest(nandsimDma->priv.sglDevice, 0);
sem_wait(&nandsimDma->priv.sglIdSem);
id = nandsimDma->priv.sglId;
// pairs of ('offset','size') pointing to space in nandsim memory
// this is unsafe. To do it properly, we should get this list from
// nandsim_exe or from the kernel driver. This code here might overrun
// the backing store allocated by nandsim_exe.
RegionRef region[] = {{0, 0x100000}, {0x100000, 0x100000}};
printf("[%s:%d]\n", __FUNCTION__, __LINE__);
int ref_haystackInNandMemory = send_reference_to_portal(nandsimDma->priv.sglDevice, sizeof(region)/sizeof(region[0]), region, id);
sem_wait(&(nandsimDma->priv.confSem));
fprintf(stderr, "%08x\n", ref_haystackInNandMemory);
//
////////////////////////////////////////////////////////////////////
if(1){
P charMapP;
P stateMapP;
P stateTransitionsP;
readfile("jregexp.charMap", &charMapP);
readfile("jregexp.stateMap", &stateMapP);
readfile("jregexp.stateTransitions", &stateTransitionsP);
portalDCacheFlushInval(charMapP.alloc, charMapP.length, charMapP.mem);
portalDCacheFlushInval(stateMapP.alloc, stateMapP.length, stateMapP.mem);
portalDCacheFlushInval(stateTransitionsP.alloc, stateTransitionsP.length, stateTransitionsP.mem);
for(int i = 0; i < num_tests; i++){
device->setup(charMapP.ref, charMapP.length);
device->setup(stateMapP.ref, stateMapP.length);
device->setup(stateTransitionsP.ref, stateTransitionsP.length);
// for this test, we are just re-usng the same haystack which
// has been written to the nandsim backing store by nandsim_exe
if(i==0){
readfile("test.bin", &haystackP[0]);
sw_match_cnt = num_tests*sw_ref(&haystackP[0], &charMapP, &stateMapP, &stateTransitionsP);
}
sem_wait(&test_sem);
int token = deviceIndication->token;
assert(token < max_num_tokens);
token_map[token] = i;
fprintf(stderr, "Main::about to invoke search %08x %08x\n", ref_haystackInNandMemory, haystack_len);
// Regexp uses a data-bus width of 8 bytes. length must be a multiple of this dimension
device->search(token, ref_haystackInNandMemory, haystack_len & ~((1<<3)-1));
}
sem_wait(&test_sem);
close(charMapP.alloc);
close(stateMapP.alloc);
close(stateTransitionsP.alloc);
}
portalExec_stop();
fprintf(stderr, "hw_match_cnt=%d, sw_match_cnt=%d\n", hw_match_cnt, sw_match_cnt);
return (hw_match_cnt == sw_match_cnt ? 0 : -1);
}
int main(int argc, const char **argv)
{
fprintf(stderr, "Main::%s %s\n", __DATE__, __TIME__);
MMURequestProxy *hostMMURequest = new MMURequestProxy(IfcNames_AlgoMMURequest);
DmaManager *hostDma = new DmaManager(hostMMURequest);
MMUIndication *hostMMUIndication = new MMUIndication(hostDma, IfcNames_AlgoMMUIndication);
MMURequestProxy *nandsimMMURequest = new MMURequestProxy(IfcNames_NandMMURequest);
DmaManager *nandsimDma = new DmaManager(nandsimMMURequest);
MMUIndication *nandsimMMUIndication = new MMUIndication(nandsimDma,IfcNames_NandMMUIndication);
StrstrRequestProxy *strstrRequest = new StrstrRequestProxy(IfcNames_AlgoRequest);
StrstrIndication *strstrIndication = new StrstrIndication(IfcNames_AlgoIndication);
MemServerIndication *hostMemServerIndication = new MemServerIndication(IfcNames_HostMemServerIndication);
//MemServerIndication *nandsimMemServerIndication = new MemServerIndication(IfcNames_NandMemServerIndication);
portalExec_start();
fprintf(stderr, "Main::allocating memory...\n");
// allocate memory for strstr data
int needleAlloc = portalAlloc(numBytes);
int mpNextAlloc = portalAlloc(numBytes);
int ref_needleAlloc = hostDma->reference(needleAlloc);
int ref_mpNextAlloc = hostDma->reference(mpNextAlloc);
fprintf(stderr, "%08x %08x\n", ref_needleAlloc, ref_mpNextAlloc);
char *needle = (char *)portalMmap(needleAlloc, numBytes);
int *mpNext = (int *)portalMmap(mpNextAlloc, numBytes);
//const char *needle_text = "ababab";
// int* target = (int*) malloc(sizeof(int));
// *target = 0x11ff;
//fprintf(stderr, "Searching for int target=%x\n", *target);
// char *needle_text = (char*) target;
//int needle_len = sizeof(int);
/*
const char *needle_text = "abab";
int needle_len = strlen(needle_text);
strncpy(needle, needle_text, needle_len);
*/
int needle_text = 0x02;
//int needle_text = 0x0000001f;
//int needle_text = 0x62616261;
int* test = &needle_text;
//int* test = (int *) needle_text;
fprintf(stderr, "searching %x\n", *test);
//int needle_len = strlen(needle_text);
//strncpy(needle, needle_text, needle_len);
int needle_len = sizeof(int);
memcpy(needle, test, sizeof(int));
compute_MP_next(needle, mpNext, needle_len);
// fprintf(stderr, "mpNext=[");
// for(int i= 0; i <= needle_len; i++)
// fprintf(stderr, "%d ", mpNext[i]);
// fprintf(stderr, "]\nneedle=[");
// for(int i= 0; i < needle_len; i++)
// fprintf(stderr, "%d ", needle[i]);
// fprintf(stderr, "]\n");
portalDCacheFlushInval(needleAlloc, numBytes, needle);
portalDCacheFlushInval(mpNextAlloc, numBytes, mpNext);
fprintf(stderr, "Main::flush and invalidate complete\n");
// fprintf(stderr, "Main::waiting to connect to nandsim_exe\n");
// wait_for_connect_nandsim_exe();
// fprintf(stderr, "Main::connected to nandsim_exe\n");
// base of haystack in "flash" memory
// this is read from nandsim_exe, but could also come from kernel driver
//int haystack_base = read_from_nandsim_exe();
//int haystack_len = read_from_nandsim_exe();
int haystack_len = 1<<31;
// request the next sglist identifier from the sglistMMU hardware module
// which is used by the mem server accessing flash memory.
int id = 0;
MMURequest_idRequest(nandsimDma->priv.sglDevice, 0);
sem_wait(&nandsimDma->priv.sglIdSem);
id = nandsimDma->priv.sglId;
// pairs of ('offset','size') pointing to space in nandsim memory
// this is unsafe. To do it properly, we should get this list from
// nandsim_exe or from the kernel driver. This code here might overrun
// the backing store allocated by nandsim_exe.
// RegionRef region[] = {{0, 0x100000}, {0x100000, 0x100000}};
RegionRef region[] = {{0x100000, 0x100000}};
printf("[%s:%d]\n", __FUNCTION__, __LINE__);
int ref_haystackInNandMemory = send_reference_to_portal(nandsimDma->priv.sglDevice, sizeof(region)/sizeof(region[0]), region, id);
sem_wait(&(nandsimDma->priv.confSem));
fprintf(stderr, "%08x\n", ref_haystackInNandMemory);
// at this point, ref_needleAlloc and ref_mpNextAlloc are valid sgListIds for use by
// the host memory dma hardware, and ref_haystackInNandMemory is a valid sgListId for
// use by the nandsim dma hardware
fprintf(stderr, "about to setup device %d %d\n", ref_needleAlloc, ref_mpNextAlloc);
strstrRequest->setup(ref_needleAlloc, ref_mpNextAlloc, needle_len);
fprintf(stderr, "about to invoke search %d\n", ref_haystackInNandMemory);
timespec start, now;
clock_gettime(CLOCK_REALTIME, & start);
strstrRequest->search(ref_haystackInNandMemory, haystack_len);
strstrIndication->wait();
clock_gettime(CLOCK_REALTIME, & now);
fprintf(stderr, "LOG: finished search! %f\n", timespec_diff_sec(start, now) );
//exit(!(strstrIndication->match_cnt==3));
fprintf(stderr, "Number of results found = %d\n", strstrIndication->match_cnt);
return 0;
}
