static void patch_aarch64(char *writeEntry, const char *execEntry, int stubSize, void *incrementPtr) { #if defined(__aarch64__) const uint32_t tmpl[] = { // ldr x0, 1f 0x580000a0, // ldr x1, [x0] 0xf9400001, // add x1, x1, #1 0x91000421, // str x1, [x0] 0xf9000001, // br x30 0xd61f03c0, // 1: 0x00000000, 0x00000000, }; static const int offsetAddr = sizeof(tmpl) - 8; if (stubSize < sizeof(tmpl)) { return; } memcpy(writeEntry, tmpl, sizeof(tmpl)); *((uint64_t *)(writeEntry + offsetAddr)) = (uint64_t) incrementPtr; __builtin___clear_cache((char *) execEntry, (char *) (execEntry + sizeof(tmpl))); #else assert(0); // Should not be calling this #endif }
void SetDispatchFuncPointer(GLVNDGenEntrypoint *entry, GLVNDentrypointStub dispatch) { uint8_t *code = entry->entrypointWrite; #if defined(USE_X86_ASM) // For x86, we use a JMP instruction with a PC-relative offset. Figure out // the offset from the generated entrypoint to the dispatch function. intptr_t offset = ((intptr_t) dispatch) - ((intptr_t) entry->entrypointExec) - DISPATCH_FUNC_OFFSET_REL; *((intptr_t *) (code + DISPATCH_FUNC_OFFSET)) = offset; #elif defined(USE_X86_64_ASM) // For x86_64, we have to use a movabs instruction, which needs the // absolute address of the dispatch function. *((GLVNDentrypointStub *) (code + DISPATCH_FUNC_OFFSET)) = dispatch; #elif defined(USE_ARMV7_ASM) *((uint32_t *)(code + DISPATCH_FUNC_OFFSET)) = (uint32_t)dispatch; // Make sure the base address has the Thumb mode bit assert((uintptr_t)entry->entrypointExec & (uintptr_t)0x1); // See http://community.arm.com/groups/processors/blog/2010/02/17/caches-and-self-modifying-code __builtin___clear_cache((char *)entry->entrypointExec - 1, (char *)entry->entrypointExec + sizeof(STUB_TEMPLATE)); #else #error "Can't happen -- not implemented" #endif }
int CodeCache::cache( const AssemblyKeyBase& keyBase, const sp<Assembly>& assembly) { pthread_mutex_lock(&mLock); const ssize_t assemblySize = assembly->size(); while (mCacheInUse + assemblySize > mCacheSize) { // evict the LRU size_t lru = 0; size_t count = mCacheData.size(); for (size_t i=0 ; i<count ; i++) { const cache_entry_t& e = mCacheData.valueAt(i); if (e.when < mCacheData.valueAt(lru).when) { lru = i; } } const cache_entry_t& e = mCacheData.valueAt(lru); mCacheInUse -= e.entry->size(); mCacheData.removeItemsAt(lru); } ssize_t err = mCacheData.add(key_t(keyBase), cache_entry_t(assembly, mWhen)); if (err >= 0) { mCacheInUse += assemblySize; mWhen++; // synchronize caches... char* base = reinterpret_cast<char*>(assembly->base()); char* curr = reinterpret_cast<char*>(base + assembly->size()); __builtin___clear_cache(base, curr); } pthread_mutex_unlock(&mLock); return err; }
static void patch_armv7_thumb(char *writeEntry, const char *execEntry, int stubSize, void *incrementPtr) { #if defined(__arm__) // Thumb bytecode const uint16_t tmpl[] = { 0x4802, // ldr r0, 1f 0x6801, // ldr r1, [r0] 0xf101, 0x0101, // add r1, r1, #1 0x6001, // str r1, [r0] 0x4770, // bx lr // 1: 0x0000, 0x0000, }; static int offsetAddr = sizeof(tmpl) - 4; if (stubSize < sizeof(tmpl)) { return; } memcpy(writeEntry, tmpl, sizeof(tmpl)); *((uint32_t *)(writeEntry + offsetAddr)) = (uint32_t)incrementPtr; __builtin___clear_cache((char *) execEntry, (char *) (execEntry + sizeof(tmpl))); #else assert(0); // Should not be calling this #endif }
void MIPSEmitter::FlushIcacheSection(u8 *start, u8 *end) { #if defined(MIPS) #ifdef __clang__ __clear_cache(start, end); #else __builtin___clear_cache(start, end); #endif #endif }
int v4_generate_JIT_code(const struct V4_Instruction* code, v4_random_math_JIT_func buf, const size_t buf_size) { #if defined __i386 || defined __x86_64__ uint8_t* JIT_code = (uint8_t*) buf; const uint8_t* JIT_code_end = JIT_code + buf_size; APPEND_CODE(prologue, sizeof(prologue)); uint32_t prev_rot_src = 0xFFFFFFFFU; for (int i = 0;; ++i) { const struct V4_Instruction inst = code[i]; if (inst.opcode == RET) break; const uint8_t opcode = (inst.opcode == MUL) ? inst.opcode : (inst.opcode + 2); const uint32_t a = inst.dst_index; const uint32_t b = inst.src_index; const uint8_t c = opcode | (inst.dst_index << V4_OPCODE_BITS) | (((inst.src_index == 8) ? inst.dst_index : inst.src_index) << (V4_OPCODE_BITS + V4_DST_INDEX_BITS)); switch (inst.opcode) { case ROR: case ROL: if (b != prev_rot_src) { prev_rot_src = b; const uint8_t* p1 = (const uint8_t*) instructions_mov[c]; const uint8_t* p2 = (const uint8_t*) instructions_mov[c + 1]; APPEND_CODE(p1, p2 - p1); } break; } if (a == prev_rot_src) prev_rot_src = 0xFFFFFFFFU; const uint8_t* p1 = (const uint8_t*) instructions[c]; const uint8_t* p2 = (const uint8_t*) instructions[c + 1]; APPEND_CODE(p1, p2 - p1); if (inst.opcode == ADD) *(uint32_t*)(JIT_code - 4) = inst.C; } APPEND_CODE(epilogue, sizeof(epilogue)); __builtin___clear_cache((char*)buf, (char*)JIT_code); return 0; #else return 1; #endif }
/*++ Function: DBG_FlushInstructionCache: processor-specific portion of FlushInstructionCache See MSDN doc. --*/ BOOL DBG_FlushInstructionCache( IN LPCVOID lpBaseAddress, IN SIZE_T dwSize) { // Intrinsic should do the right thing across all platforms __builtin___clear_cache((char *)lpBaseAddress, (char *)((INT_PTR)lpBaseAddress + dwSize)); return TRUE; }
static inline void ffi_clear_cache (void *start, void *end) { #if defined (__clang__) && defined (__APPLE__) sys_icache_invalidate (start, (char *)end - (char *)start); #elif defined (__GNUC__) __builtin___clear_cache (start, end); #else #error "Missing builtin to flush instruction cache" #endif }
TCA emitCallToExit(CodeBlock& cb, DataBlock& data, const UniqueStubs& us) { vixl::MacroAssembler a { cb }; vixl::Label target_data; auto const start = cb.frontier(); // Jump to enterTCExit a.Ldr(rAsm, &target_data); a.Br(rAsm); a.bind(&target_data); a.dc64(us.enterTCExit); __builtin___clear_cache(reinterpret_cast<char*>(start), reinterpret_cast<char*>(cb.frontier())); return start; }
int cacheflush(long start, long end, long /*flags*/) { if (end < start) { // It looks like this is really a MIPS-style cacheflush call. static bool warned = false; if (!warned) { __libc_format_log(ANDROID_LOG_WARN, "libc", "cacheflush called with (start,len) instead of (start,end)"); warned = true; } end += start; } // Use the GCC builtin. This will generate inline synci instructions if available, // or call _flush_cache(start, len, BCACHE) directly. __builtin___clear_cache(reinterpret_cast<char*>(start), reinterpret_cast<char*>(end)); return 0; }
static void patch_armv7_thumb_tsd(char *writeEntry, const char *execEntry, int stubSize) { #if defined(__arm__) char *pSawVertex3fv = (char *)&__glXSawVertex3fv; // Thumb bytecode char tmpl[] = { // ldr r0, 1f 0x48, 0x02, // ldr r1, [r0] 0x68, 0x01, // add r1, r1, #1 0xf1, 0x01, 0x01, 0x01, // str r1, [r0] 0x60, 0x01, // bx lr 0x47, 0x70, // 1: 0x00, 0x00, 0x00, 0x00, }; int offsetAddr = sizeof(tmpl) - 4; if (stubSize < sizeof(tmpl)) { return; } #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ glvnd_byte_swap16((uint16_t *)tmpl, offsetAddr); #endif *((uint32_t *)(tmpl + offsetAddr)) = (uint32_t)pSawVertex3fv; memcpy(writeEntry, tmpl, sizeof(tmpl)); __builtin___clear_cache((char *) execEntry, (char *) (execEntry + sizeof(tmpl))); #else assert(0); // Should not be calling this #endif }
void entry_generate_default_code(char *entry, int slot) { char *writeEntry; // Make sure the base address has the Thumb mode bit assert((uintptr_t)entry & (uintptr_t)0x1); // Get the pointer to the writable mapping. writeEntry = (char *) u_execmem_get_writable(entry - 1); memcpy(writeEntry, BYTECODE_TEMPLATE, ARMV7_BYTECODE_SIZE); *((uint32_t *)(writeEntry + TEMPLATE_OFFSET_SLOT)) = slot; *((uint32_t *)(writeEntry + TEMPLATE_OFFSET_CURRENT_TABLE)) = (uint32_t)_glapi_Current; *((uint32_t *)(writeEntry + TEMPLATE_OFFSET_CURRENT_TABLE_GET)) = (uint32_t)_glapi_get_current; // See http://community.arm.com/groups/processors/blog/2010/02/17/caches-and-self-modifying-code __builtin___clear_cache(writeEntry, writeEntry + ARMV7_BYTECODE_SIZE); }
void* EmitJumpInstruction(void* from_, const void* to_) { BYTE *base, *from, *to; base = from = (BYTE*)from_; to = (BYTE*)to_; BYTE* jump_from = from + 5; size_t distance = jump_from > to ? jump_from - to : to - jump_from; // emit 5 byte jmp (0xe9 RVA) if relative address is less than 32 bit. // otherwise emit 14 byte long jmp (0xff 0x25 [memory] + target) if (distance <= 0x7fff0000) { from[0] = 0xe9; from += 1; *((DWORD*)from) = (DWORD)((size_t)to - (size_t)jump_from); from += 4; } else { from[0] = 0xff; from[1] = 0x25; from += 2; #if defined(__Arch_x86_64__) *((DWORD*)from) = (DWORD)((size_t)from + 4); #elif defined(__Arch_x86__) *((DWORD*)from) = (DWORD)0; #endif from += 4; *((DWORD_PTR*)from) = (DWORD_PTR)(to); from += 8; } #ifdef _WIN32 ::FlushInstructionCache(nullptr, base, size_t(from - base)); #else __builtin___clear_cache((char*)from, (char*)base); #endif return from; }
static void sys_cacheflush(void *start, void *end) { //__android_log_print(ANDROID_LOG_INFO,"nds4droid","sys_cacheflush %x %x", (unsigned long)start, (unsigned long)end); __builtin___clear_cache(start,end); /* #ifdef __ARM_EABI__ // EABI version * int num = __ARM_NR_cacheflush; __asm__("mov r0, %0 ;" "mov r1, %1 ;" "mov r2, #0 ;" "mov r7, %2 ;" "swi 0" : : "r" (start), "r" (end), "r" (num) : "r0", "r1", "r2", "r3", "r7"); #else // OABI __asm__("mov r0, %0 ;" "mov r1, %1 ;" "mov r2, #0 ;" "swi %2" : : "r" (start), "r" (end), "i" __ARM_NR_cacheflush : "r0", "r1", "r2", "r3"); #endif */ }
/* * Copyright (c) 2017, 2018, Oracle and/or its affiliates. * * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, are * permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright notice, this list of * conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright notice, this list of * conditions and the following disclaimer in the documentation and/or other materials provided * with the distribution. * * 3. Neither the name of the copyright holder nor the names of its contributors may be used to * endorse or promote products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. */ int main() { char a[100]; __builtin___clear_cache(a, a + 100); return 0; }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* build the entry */ entry *pHead, *e; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; e->pNext = NULL; entry *hash_table[1000] = {NULL},*hash_head[1000]= {NULL}; #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; #if defined(OPT) unsigned int key; key = hash(line); key = key % 1000; if(hash_head[key] == NULL) { hash_head[key] = (entry*)malloc(sizeof(entry)); hash_table[key] = hash_head[key]; } hash_table[key] = append(line,hash_table[key]); #else e = append(line, e); #endif } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); e = pHead; /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; #if defined(OPT) unsigned int k = hash(input) % 1000; e = hash_head[k]; #else e = pHead; #endif assert(findName(input, e) && "Did you implement findName() in " IMPL "?"); assert(0 == strcmp(findName(input, e)->lastName, "zyxel")); #if defined(OPT) __builtin___clear_cache((char *) hash_head, (char *) hash_head + 1000 * sizeof(entry)); #endif #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); findName(input, e); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); FILE *output; #if defined(OPT) output = fopen("opt.txt", "a"); #else output = fopen("orig.txt", "a"); #endif fprintf(output, "append() findName() %lf %lf\n", cpu_time1, cpu_time2); fclose(output); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); if (pHead->pNext) free(pHead->pNext); free(pHead); return 0; }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } #ifndef PHONEBOOKOPT /* build the entry */ entry *pHead, *e; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; e->pNext = NULL; #else threadArg *threadData = malloc(sizeof(struct __THREAD_ARG)); void *status; hash *e; hash *pHead = malloc(26 * sizeof(hash)); for ( int i = 0 ; i < 26 ; i++ ) pHead[i].pNamelist = NULL; printf("size of entry : %lu bytes\n", sizeof(pHead[0])); e = pHead; threadData ->fp = fp; threadData ->e = e; #endif #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); #ifndef PHONEBOOKOPT while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; e = append(line, e); } #else pthread_attr_t attr; pthread_mutex_init(&mutexsum, NULL); /* Create threads */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); for (long t = 0 ; t < NUMTHREADS ; t++) { pthread_create(&callThd[t], &attr, import, (void *)threadData); } pthread_attr_destroy(&attr); for (long t = 0 ; t < NUMTHREADS ; t++) { pthread_join(callThd[t], &status); } #endif /* close file as soon as possible */ fclose(fp); clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); e = pHead; /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; e = pHead; assert(findName(input, e) && "Did you implement findName() in " IMPL "?"); assert(0 == strcmp(findName(input, e)->lastName, "zyxel")); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); findName(input, e); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); /* FIXME: release all allocated entries */ free(pHead); pthread_mutex_destroy(&mutexsum); pthread_exit(NULL); return 0; }
void f() { int size = 40; char *memory = __builtin_alloca(size); __builtin___clear_cache(memory, memory + size); }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* setting mempool and build the entry*/ #if defined(OPT) initMemPool(); printf("size of entry : %lu bytes\n", sizeof(entry)); #else entry *pHead, *e; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; e->pNext = NULL; #endif #if defined(OPT) #if defined(__GNUC__) __builtin___clear_cache((char *) HashTable, (char *) HashTable + sizeof(entry)); #endif #else #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif #endif #if defined(OPT) #if defined(SLOT) int hash_slot[HASH_TABLE_SIZE] = {0}; #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; #if defined(SLOT) hash_slot[hash(line)]++; #endif if(append(line, HashTable)==NULL) puts("apped failed, the lastName is not valid."); } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; assert(findName(input, HashTable) && "Did you implement findName() in " IMPL "?"); assert(0 == strcmp(findName(input, HashTable)->lastName, "zyxel")); #else clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; if((e = append(line, e))==NULL) puts("apped failed, the lastName is not valid."); } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); e = pHead; /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; e = pHead; assert(findName(input, e) && "Did you implement findName() in " IMPL "?"); assert(0 == strcmp(findName(input, e)->lastName, "zyxel")); #endif #if defined(OPT) #if defined(__GNUC__) __builtin___clear_cache((char *) HashTable, (char *) HashTable + sizeof(entry)); #endif #else #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif #endif /* compute the execution time */ #if defined(OPT) clock_gettime(CLOCK_REALTIME, &start); findName(input, HashTable); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); #else clock_gettime(CLOCK_REALTIME, &start); findName(input, e); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); #endif FILE *output; #if defined(OPT) output = fopen("opt.txt", "a"); #if defined(SLOT) FILE *output2; output2 = fopen("slot.txt", "a"); for(int i = 0; i < HASH_TABLE_SIZE; i++) { fprintf(output2, "%d %d\n", i, hash_slot[i]); } fclose(output2); #endif #else output = fopen("orig.txt", "a"); #endif fprintf(output, "append() findName() %lf %.9lf\n", cpu_time1, cpu_time2); fclose(output); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %.9lf sec\n", cpu_time2); #if defined(OPT) mempoolfree(); #else if (pHead->pNext) free(pHead->pNext); free(pHead); #endif return 0; }
int main() { __builtin___clear_cache(buffer, buffer+32); // CHECK: @llvm.clear_cache(i8* getelementptr inbounds ({{.*}}, i8* getelementptr inbounds (i8, i8* getelementptr inbounds ({{.*}} 32)) return 0; }
TEST(sys_mman, mmap_bug_27265969) { char* base = reinterpret_cast<char*>(mmap(nullptr, PAGE_SIZE * 2, PROT_EXEC | PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, 0, 0)); // Some kernels had bugs that would cause segfaults here... __builtin___clear_cache(base, base + (PAGE_SIZE * 2)); }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* build the entry */ entry *pHead, *e; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; // two pointer point to the same address(e points to the address that pHead points to) e->pNext = NULL; #if defined(OPT) // define hash table #define MAX_TABLE_SIZE 1000 entry *hash_pHead[MAX_TABLE_SIZE], *hash_e[MAX_TABLE_SIZE]; unsigned long j; for(j = 0; j < MAX_TABLE_SIZE; j++) { hash_pHead[j] = (entry *) malloc(sizeof(entry)); hash_e[j] = hash_pHead[j]; hash_e[j]->pNext = NULL; } #endif #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { // read each line in words.txt and store it to the array variable 'line' while (line[i] != '\0') i++; line[i - 1] = '\0'; // "aLastName\n\0" ==> "aLastName\0\0" i = 0; #if defined(OPT) unsigned long hash_addr = getHash_addr(line,MAX_TABLE_SIZE); hash_e[hash_addr] = append(line, hash_e[hash_addr]); #else e = append(line, e); // when use strcpy "aLastName\0\0" ==> "aLastName\0" #endif } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; #if defined(OPT) unsigned long inputHash_addr = getHash_addr(input,MAX_TABLE_SIZE); e = hash_pHead[inputHash_addr]; #else e = pHead; #endif assert(findName(input, e) && "Did you implement findName() in " IMPL "?"); // the string "Did you ..." will be print with assert assert(0 == strcmp(findName(input, e)->lastName, "zyxel")); // if find "zyxel" then continue, otherwise the program terminates #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); findName(input, e); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); FILE *output; #if OPT==1 output = fopen("opt.txt", "a"); //append text to the original file #else output = fopen("orig.txt", "a"); #endif fprintf(output, "append() findName() %lf %lf\n", cpu_time1, cpu_time2); fclose(output); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); if (pHead->pNext) free(pHead->pNext); free(pHead); return 0; }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2=0; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* build the entry */ PHONEBOOK.initialize(); printf("size of entry : %lu bytes\n", sizeof(entry)); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; PHONEBOOK.addNode(line,e); } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); /* the givn last name to find */ char input[INPUT_SIZE][MAX_LAST_NAME_SIZE] = {"uninvolved","zyxel","whiteshank", "odontomous", "pungoteague", "reweighted", "xiphisternal", "yakattalo" }; for( i = 0; i < INPUT_SIZE; i++ ) { char in[MAX_LAST_NAME_SIZE]; PHONEBOOK.get_cmp_buf(input[i],in); PHONEBOOK.moveNode(); /*Get compress input value*/ assert(PHONEBOOK.findName(input[i], e) && "Did you implement findName() in " IMPL "?"); #ifndef FUZZY_SEARCH assert(0 == strcmp(PHONEBOOK.findName(input[i], e)->lastName, in)); #endif #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); entry *result = PHONEBOOK.findName(input[i], e); #ifdef SHOW_RESULT if(0 == strcmp(result -> lastName,in)) { //printf("Find %s\n",input[i]); } else { char output[MAX_LAST_NAME_SIZE]; int count = 0; int input_len = strlen(in); int result_len,max_len,r; float radio; while (result != NULL) { decompress(result->lastName,output); result_len = strlen(output); if(abs(result_len - input_len) <= STRING_COMPARISON_LENGTH) { max_len = (result_len < input_len) ? input_len : result_len; r = Levenshtein(output,in); radio = 1.0 - ((float)r) / max_len; if(radio > STRING_COMPARISON_THRESHOLD) { //printf("Simular Result : %s \t result : %d \t radio : %.2f \n",result->lastName,r,radio); count++; } } result = result -> pNext; } //printf("Candidate count is %d \n",count); } #endif clock_gettime(CLOCK_REALTIME, &end); cpu_time2 += diff_in_second(start, end); } printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); /* FIXME: release all allocated entries */ PHONEBOOK.release(); return 0; }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* build the entry */ entry *pHead, *e; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; e->pNext = NULL; #if defined(OPT) hashTable *ht = createHashTable(TABLE_SIZE); printf("Hash Table Size: %d\n", TABLE_SIZE); #endif #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; #if defined(OPT) e = append(line, ht); #else e = append(line, e); #endif } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_milisecond(start, end); /* close file as soon as possible */ fclose(fp); /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = FIND_NAME; void *findPtr = NULL; #if defined(OPT) findPtr = ht; #else findPtr = pHead; #endif assert(findName(input, findPtr) && "Did you implement findName() in " IMPL "?"); assert(0 == strcmp(findName(input, findPtr)->lastName, "zyxel")); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); findName(input, findPtr); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_milisecond(start, end); printf("execution time of append() : %lf ms\n", cpu_time1); printf("execution time of findName() : %lf ms\n", cpu_time2); /* FIXME: release all allocated entries */ free(pHead); return 0; }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* build the entry */ entry *pHead; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); //create hashtable hashtable *hashtable = ht_create(65536); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; //add data ht_append(hashtable , line); } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); //find data ht_findName(hashtable,input); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); /* FIXME: release all allocated entries */ free(pHead); return 0; }
void Mem::flushInstructionCache(void *p, size_t size) { # ifndef __FreeBSD__ __builtin___clear_cache(reinterpret_cast<char*>(p), reinterpret_cast<char*>(p) + size); # endif }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* build the entry */ PHONE_BOOK.initialize(); printf("size of entry : %u bytes\n", sizeof(entry)); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; PHONE_BOOK.new_node(line, e); } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); PHONE_BOOK.move_node(); /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; //assert(PHONE_BOOK.findName(input, e) && // "Did you implement findName() in " IMPL "?"); //assert(0 == strcmp(PHONE_BOOK.findName(input, e) -> lastName, "zyxel")); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); PHONE_BOOK.findName(input, e); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); /* FIXME: release all allocated entries */ PHONE_BOOK.release(); return 0; }
int main(int argc, char *argv[]) { FILE **fps; struct timespec start, end; double cpu_time1, cpu_time2; int threadnum = 10; /* printf("Specify number of worker threads: "); scanf("%d", &threadnum); */ /* check file opening */ int k; fps = (FILE **)malloc(threadnum * sizeof(FILE *)); for(k = 0; k < threadnum; k++) { fps[k] = fopen(DICT_FILE, "r"); if (fps[k] == NULL) { printf("cannot open the file\n"); return -1; } } /* build the entry */ entry *pHead, *e; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; e->pNext = NULL; #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif pthread_t *threads = (pthread_t *)malloc(threadnum * sizeof(pthread_t)); thread_data **param = (thread_data **)malloc(threadnum * sizeof(thread_data *)); for(int k=0; k < TABLE_SIZE; k++) { if (pthread_mutex_init(&locks[k], NULL) != 0) { printf("\n mutex init failed\n"); return 1; } } clock_gettime(CLOCK_REALTIME, &start); int err; for(k = 0; k < threadnum; k++) { param[k] = pack_param(fps[k], k, threadnum); err = pthread_create(&threads[k], NULL, (void *) &thread_work, (void *) param[k]); if (err != 0) printf("\ncan't create thread :[%s]", strerror(err)); } for(k = 0; k < threadnum; k++) { pthread_join(threads[k], NULL); } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ for(k = 0; k < threadnum; k++) { fclose(fps[k]); } for(int k=0; k < TABLE_SIZE; k++) { // printf("%d\n", hash_stats[k]); pthread_mutex_destroy(&locks[k]); } e = pHead; /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; e = pHead; assert(findName(input, e) && "Did you implement findName() in " IMPL "?"); assert(0 == strcmp(findName(input, e)->lastName, "zyxel")); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); findName(input, e); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); FILE *output; #if defined(OPT) output = fopen("opt.txt", "a"); #else output = fopen("orig.txt", "a"); #endif fprintf(output, "append() findName() %lf %lf\n", cpu_time1, cpu_time2); fclose(output); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); if (pHead->pNext) free(pHead->pNext); free(pHead); return 0; }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* build the entry */ entry *pHead, *e; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; e->pNext = NULL; #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; e = append(line, e); } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); e = pHead; /* the givn last name to find */ char input[MAX_LAST_NAME_SIZE] = "zyxel"; e = pHead; assert(findName(input, e) && "Did you implement findName() in " IMPL "?"); assert(0 == strcmp(findName(input, e)->lastName, "zyxel")); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); findName(input, e); clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); free_struct(e); return 0; }
int main(int argc, char *argv[]) { FILE *fp; int i = 0; char line[MAX_LAST_NAME_SIZE]; struct timespec start, end; double cpu_time1, cpu_time2; /* check file opening */ fp = fopen(DICT_FILE, "r"); if (fp == NULL) { printf("cannot open the file\n"); return -1; } /* build the entry */ # if defined(OPT) entry **pHead, **e; pHead = (entry **) malloc(sizeof(entry*) * TABLESIZE); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; for(i = 0; i < TABLESIZE; i++) { e[i] = (entry*) malloc(sizeof(entry)); e[i]->pNext = NULL; } i = 0; #else entry *pHead, *e; pHead = (entry *) malloc(sizeof(entry)); printf("size of entry : %lu bytes\n", sizeof(entry)); e = pHead; #endif #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif clock_gettime(CLOCK_REALTIME, &start); while (fgets(line, sizeof(line), fp)) { while (line[i] != '\0') i++; line[i - 1] = '\0'; i = 0; e = append(line, e); } clock_gettime(CLOCK_REALTIME, &end); cpu_time1 = diff_in_second(start, end); /* close file as soon as possible */ fclose(fp); e = pHead; /* the givn last name to find */ char input[8][MAX_LAST_NAME_SIZE]; strcpy(input[0], "zyxel"); strcpy(input[1], "uninvolved"); strcpy(input[2], "whiteshank"); strcpy(input[3], "odontomous"); strcpy(input[4], "pungoteague"); strcpy(input[5], "reweighted"); strcpy(input[6], "xiphisternal"); strcpy(input[7], "yakattalo"); e = pHead; assert(findName(input[0], e) && "Did you implement findName() in " IMPL "?"); assert(0 == strcmp(findName(input[0], e)->lastName, "zyxel")); #if defined(__GNUC__) __builtin___clear_cache((char *) pHead, (char *) pHead + sizeof(entry)); #endif /* compute the execution time */ clock_gettime(CLOCK_REALTIME, &start); for(i = 0; i < 8; i++) { findName(input[i], e); } clock_gettime(CLOCK_REALTIME, &end); cpu_time2 = diff_in_second(start, end); FILE *output; #if defined(OPT) output = fopen("opt.txt", "a"); #else output = fopen("orig.txt", "a"); #endif fprintf(output, "append() findName() %lf %lf\n", cpu_time1, cpu_time2); fclose(output); printf("execution time of append() : %lf sec\n", cpu_time1); printf("execution time of findName() : %lf sec\n", cpu_time2); printf("total time elapsed : %lf sec\n", cpu_time1 + cpu_time2); #if defined(OPT) for(i = 0; i < TABLESIZE; i++) { if (pHead[i]->pNext) free(pHead[i]->pNext); } #else if (pHead->pNext) free(pHead->pNext); #endif free(pHead); return 0; }