//--------------------------------------- // Main program //--------------------------------------- void main(void) { InitSerial(); // Initialize serial port putchar(0x0C); // clear hyper terminal DelayMs(5); WriteBYTE(0x0000); WriteI2C('A'); //Write Data's Here WriteI2C('B'); WriteI2C('C'); WriteI2C('D'); WriteI2C('E'); WriteI2C('F'); Stop(); DelayMs(10); ReadBYTE(0x0000); EData[0] = ReadI2C(NO_ACK); EData[1] = ReadI2C(NO_ACK); EData[2] = ReadI2C(NO_ACK); EData[3] = ReadI2C(NO_ACK); EData[4] = ReadI2C(NO_ACK); EData[5] = ReadI2C(NO_ACK); for(i=0;i<6;i++) { printf("value = %c\n",EData[i]); // display data */ DelayMs(100); } while(1); }
String TSearchFilesFrm::GetSearchData() { AnsiString data; AnsiString content_text = edtSearchContent->Text; if(cbSearchMode->ItemIndex == 0) { data = content_text; } else if(cbSearchMode->ItemIndex == 1) { data = BinToStr(content_text.c_str(), content_text.Length()); } else if(cbSearchMode->ItemIndex == 2) { DWORD num = content_text.ToInt(); data.SetLength(4); int pos = 0; WriteDWORD(data.c_str(), pos, num); data = BinToStr(data.c_str(), data.Length()); } else if(cbSearchMode->ItemIndex == 3) { WORD num = content_text.ToInt(); data.SetLength(2); int pos = 0; WriteWORD(data.c_str(), pos, num); data = BinToStr(data.c_str(), data.Length()); } else if(cbSearchMode->ItemIndex == 4) { BYTE num = content_text.ToInt(); data.SetLength(1); int pos = 0; WriteBYTE(data.c_str(), pos, num); data = BinToStr(data.c_str(), data.Length()); } return data; }
void PatchBlob( Blob& rOutputBlob, const ShaderArgs& rArgs, const Blob& rTemplateBlob, size_t nTemplateIsaStart ) { // // Summary of what I know about the blob layout: // // // DWORD 0: 0x00003142 This is a 4CC code "B1" // DWORD 1: 0x020423c8. Version number? Device number? dunno // DWORD 2 looks like it contains the blob length minus some constant // but this field is itself shifted one byte. the lower 8 bits are 0xB...? // ^ // | Rest is unknown // V // DWORD 16 threadgroup size X // DWORD 17 " " Y (-1 if not specified) // DWORD 18 " " Z (-1 if not specified) // ^ // | // | Unknown length and contents // | AT SOME POINT IN HERE, WE STOP BEING DWORD ALIGNED // | // | // V // ^ // | Various pre-isa fields, a few of which are understood // | (see below) // V // ^ // | // | ISA !NOT DWORD ALIGNED! // | // V // ^ // | // | Padding to align ISA to 64 bytes // | // V // ^ // | // | 512 bytes of zero padding // | // V // CURBE data // .... // .... // ^ // | // | Unknown length and content // V // Last two DWORDS are a hash // // By comparing different shaders I was able to decipher the important looking parts of the blob prior to the isa // // At isa-24 is the number of threads in the OpenGL workgroup grid (width*height*depth) // At isa-32 is the SIMD mode (0 for SIMD0, 1 for SIMD16) // At isa-104 and isa-702 is the number of 256-bit CURBE entries per hardware thread // At isa-100 and isa-700 is the number of HW threads // At isa-4 and isa-128 is the length of the isa block (including padding) // At isa-40 is the length of the CURBE data // // // The Isa block is always padded with 512 bytes (128 DWORDS) of zero. // Intel docs state that the 128 bytes following the last instruction are MBZ // because instruction prefetching will yank those bytes in before the EU realizes the thread is done // // 512 bytes is more padding than we need. Either the docs are wrong, or the driver is over-zealous // Or else there's something there I haven't figured out yet. const unsigned char* pTemplate = ((const unsigned char*)rTemplateBlob.GetBytes()); const unsigned char* isa = pTemplate + nTemplateIsaStart; DWORD dwGridSize = FetchDWORD(isa-24); // width*height*depth for the GL threadgroup DWORD dwMode = FetchDWORD(isa-32); // 0 for SIMD8, 1 for SIMD16 DWORD dwCURBEEntrySize = FetchDWORD(isa-104); DWORD dwThreadCount = FetchDWORD(isa-100); // also at isa-700 DWORD dwIsaLength = FetchDWORD(isa-4); // also at isa-128 DWORD dwCURBELength = FetchDWORD(isa-40); size_t nPreIsaLength = nTemplateIsaStart; size_t nPostCURBEStart = nTemplateIsaStart + dwIsaLength + dwCURBELength; size_t nPostCURBELength = rTemplateBlob.GetLength() - nPostCURBEStart; size_t nNewIsaLength = 512 + ( (rArgs.nIsaLength + 63) & ~63); size_t nNewCURBELength = rArgs.nCURBEAllocsPerThread*rArgs.nDispatchThreadCount*32; size_t nNewBlobSize = nPreIsaLength + nPostCURBELength + nNewIsaLength + nNewCURBELength; rOutputBlob.SetLength(nNewBlobSize); unsigned char* pNewBlob = (unsigned char*) rOutputBlob.GetBytes(); unsigned char* pNewIsa = pNewBlob + nPreIsaLength; unsigned char* pNewCURBE = pNewIsa + nNewIsaLength; unsigned char* pNewPostCURBE = pNewCURBE + nNewCURBELength; // copy pre-Isa blob memcpy( pNewBlob, pTemplate, nPreIsaLength ); // copy the new Isa into place and add the padding memcpy( pNewIsa, rArgs.pIsa, rArgs.nIsaLength ); memset( pNewIsa + rArgs.nIsaLength, 0, nNewIsaLength - rArgs.nIsaLength ); // copy the new CURBE into place memcpy( pNewCURBE, rArgs.pCURBE, nNewCURBELength ); // copy post-CURBE blob memcpy(pNewPostCURBE, pTemplate + nPostCURBEStart, nPostCURBELength ); // override the fields we might need to change DWORD nDispatchMode = 0; switch( rArgs.nSIMDMode ) { case 16: nDispatchMode = 1; break; case 32: nDispatchMode = 2; break; case 8: default: break; // keep SIMD8 dispatch (mode=0) } WriteDWORD( pNewIsa-32, nDispatchMode ); // change thread grid size WriteDWORD( pNewIsa-24, (8<<nDispatchMode)*rArgs.nDispatchThreadCount ); // change HW thread count WriteDWORD( pNewIsa-100, rArgs.nDispatchThreadCount ); WriteBYTE( pNewIsa-700, rArgs.nDispatchThreadCount ); // change CURBE allocation size WriteDWORD( pNewIsa-104, rArgs.nCURBEAllocsPerThread ); WriteBYTE( pNewIsa-702, rArgs.nCURBEAllocsPerThread ); // change CURBE length WriteDWORD( pNewIsa-40, nNewCURBELength ); // change Isa length WriteDWORD( pNewIsa-4, nNewIsaLength ); WriteDWORD( pNewIsa-128, nNewIsaLength ); // Near the top, we have blob_length minus some constant. 696, in the case of our sample blobs // This looks to be a "how many bytes follow" field // // Not sure if the 696 is fixed or varies with the particular GLSL program // Let's assume it varies... // DWORD nSizeDifference = rTemplateBlob.GetLength() - FetchDWORD( pTemplate + 13 ); WriteDWORD( pNewBlob + 13, nNewBlobSize - nSizeDifference ); // fix the hash DriverHashFunction( (DWORD*)(pNewBlob + (nNewBlobSize-8)), (DWORD*)pNewBlob, (nNewBlobSize-8)/4 ); }