bool WorkflowJSON_Impl::checkForUpdates()
{
std::string h1 = hash();
std::string h2 = computeHash();
bool result = (h1 != h2);
if (result){
onUpdate();
h2 = computeHash(); // recompute hash after updating timestamps in onUpdate
m_value["hash"] = h2;
}
return result;
}
//==============================================================================
Error Material::createProgramSourceToCache(
const TempResourceString& source, TempResourceString& out)
{
Error err = ErrorCode::NONE;
auto alloc = m_resources->_getTempAllocator();
// Create the hash
U64 h = computeHash(&source[0], source.getLength());
TempResourceString prefix;
TempResourceString::ScopeDestroyer prefixd(&prefix, alloc);
ANKI_CHECK(prefix.toString(alloc, h));
// Create path
ANKI_CHECK(out.sprintf(alloc, "%s/mtl_%s.glsl",
&m_resources->_getCacheDirectory()[0],
&prefix[0]));
// If file not exists write it
if(!fileExists(out.toCString()))
{
// If not create it
File f;
ANKI_CHECK(f.open(out.toCString(), File::OpenFlag::WRITE));
ANKI_CHECK(f.writeText("%s\n", &source[0]));
}
return err;
}
NetworkCacheKey::NetworkCacheKey(const String& method, const String& partition, const String& identifier)
: m_method(method.isolatedCopy())
, m_partition(partition.isolatedCopy())
, m_identifier(identifier.isolatedCopy())
, m_hash(computeHash())
{
}
//------------------------------------------------------------------------------
void Solver::HashTable::Fill
(
const IDList& particleIDs
)
{
// clear all buckets
for (unsigned int i = 0; i < mDomain.Dimensions.X*mDomain.Dimensions.Y; i++)
{
mBuckets[i].clear();
}
// fill buckets
IDList::const_iterator i = particleIDs.begin();
IDList::const_iterator e = particleIDs.end();
for (; i != e; i++)
{
unsigned int hash = computeHash
(
Vector2f(&mPositions[2*(*i)]),
mDomain
);
mBuckets[hash].push_back(*i);
}
}
void PipelineImpl::initDepthStencilState()
{
const auto& ds = m_in.m_depthStencil;
// Depth
m_cache.m_depthCompareFunction = convertCompareOperation(ds.m_depthCompareFunction);
// Stencil
m_cache.m_stencilFailOp[0] = convertStencilOperation(ds.m_stencilFront.m_stencilFailOperation);
m_cache.m_stencilPassDepthFailOp[0] = convertStencilOperation(ds.m_stencilFront.m_stencilPassDepthFailOperation);
m_cache.m_stencilPassDepthPassOp[0] = convertStencilOperation(ds.m_stencilFront.m_stencilPassDepthPassOperation);
m_cache.m_stencilCompareFunc[0] = convertCompareOperation(ds.m_stencilFront.m_compareFunction);
m_cache.m_stencilFailOp[1] = convertStencilOperation(ds.m_stencilBack.m_stencilFailOperation);
m_cache.m_stencilPassDepthFailOp[1] = convertStencilOperation(ds.m_stencilBack.m_stencilPassDepthFailOperation);
m_cache.m_stencilPassDepthPassOp[1] = convertStencilOperation(ds.m_stencilBack.m_stencilPassDepthPassOperation);
m_cache.m_stencilCompareFunc[1] = convertCompareOperation(ds.m_stencilBack.m_compareFunction);
if(stencilTestDisabled(ds.m_stencilFront) && stencilTestDisabled(ds.m_stencilBack))
{
m_stencilTestEnabled = false;
}
else
{
m_stencilTestEnabled = true;
}
m_hashes.m_depthStencil = computeHash(&ds, sizeof(ds));
}
void PipelineImpl::initRasterizerState()
{
switch(m_in.m_rasterizer.m_fillMode)
{
case FillMode::POINTS:
m_cache.m_fillMode = GL_POINT;
break;
case FillMode::WIREFRAME:
m_cache.m_fillMode = GL_LINE;
break;
case FillMode::SOLID:
m_cache.m_fillMode = GL_FILL;
break;
default:
ANKI_ASSERT(0);
}
switch(m_in.m_rasterizer.m_cullMode)
{
case FaceSelectionMask::FRONT:
m_cache.m_cullMode = GL_FRONT;
break;
case FaceSelectionMask::BACK:
m_cache.m_cullMode = GL_BACK;
break;
case FaceSelectionMask::FRONT_AND_BACK:
m_cache.m_cullMode = GL_FRONT_AND_BACK;
break;
default:
ANKI_ASSERT(0);
}
m_hashes.m_rasterizer = computeHash(&m_in.m_rasterizer, sizeof(m_in.m_rasterizer));
}
void PipelineImpl::initInputAssemblerState()
{
switch(m_in.m_inputAssembler.m_topology)
{
case PrimitiveTopology::POINTS:
m_cache.m_topology = GL_POINTS;
break;
case PrimitiveTopology::LINES:
m_cache.m_topology = GL_LINES;
break;
case PrimitiveTopology::LINE_STIP:
m_cache.m_topology = GL_LINE_STRIP;
break;
case PrimitiveTopology::TRIANGLES:
m_cache.m_topology = GL_TRIANGLES;
break;
case PrimitiveTopology::TRIANGLE_STRIP:
m_cache.m_topology = GL_TRIANGLE_STRIP;
break;
case PrimitiveTopology::PATCHES:
m_cache.m_topology = GL_PATCHES;
break;
default:
ANKI_ASSERT(0);
}
m_hashes.m_inputAssembler = computeHash(&m_in.m_inputAssembler, sizeof(m_in.m_inputAssembler));
}
//------------------------------------------------------------------------------
void Solver::HashTable::Query (const Vector2f& position, float range)
{
// reset previous result
mResult.clear();
Vector2f begf(position);
begf.X -= range;
begf.Y -= range;
Vector2f endf(position);
endf.X += range;
endf.Y += range;
Vector2ui beg = computeCoordinate(begf, mDomain);
Vector2ui end = computeCoordinate(endf, mDomain);
for (unsigned int i = beg.X; i <= end.X; i++)
{
for (unsigned int j = beg.Y; j <= end.Y; j++)
{
unsigned int hash = computeHash(i, j, mDomain.Dimensions.X);
mResult.insert
(
mResult.end(),
mBuckets[hash].begin(),
mBuckets[hash].end()
);
}
}
}
static
pt_value *contextElement(pt_context *context, char *name) {
extern pt_value UNDEF;
pt_context_node *node = context->tail;
pt_context_elem *elem = node->head;
int hash = computeHash(name);
while(elem != NULL) {
if(elem->hash == hash) {
return &elem->value;
}
}
elem = createContextElem(UNDEF);
if(elem == NULL) return NULL;
elem->hash = hash;
if(node->tail != NULL) {
node->head = node->tail = elem;
} else {
node->tail->next = elem;
node->tail = elem;
}
return &elem->value;
}
QByteArray HashFile::toHashFileContent()
{
if (m_hash.isEmpty())
if (!computeHash())
return QByteArray();
return m_hash.toHex() + QByteArray(" ") + m_fileName.toUtf8() + QByteArray("\n");
}
DisassemblyData::DisassemblyData(u32 _address, u32 _size, DataType _type): address(_address), size(_size), type(_type)
{
auto memLock = Memory::Lock();
if (!PSP_IsInited())
return;
hash = computeHash(address,size);
createLines();
}
void DisassemblyData::recheck()
{
u32 newHash = computeHash(address,size);
if (newHash != hash)
{
hash = newHash;
createLines();
}
}
DisassemblyFunction::DisassemblyFunction(u32 _address, u32 _size): address(_address), size(_size)
{
auto memLock = Memory::Lock();
if (!PSP_IsInited())
return;
hash = computeHash(address,size);
load();
}
unsigned Register::getHash() const {
switch (type) {
case Types::Tag::Integer:
return intValue;
case Types::Tag::Char:
return computeHash(stringValue.data(), stringValue.length());
}
return 0;
}
void DisassemblyFunction::recheck()
{
u32 newHash = computeHash(address,size);
if (hash != newHash)
{
hash = newHash;
clear();
load();
}
}
/** Compute Tor SAFECOOKIE response.
*
* ServerHash is computed as:
* HMAC-SHA256("Tor safe cookie authentication server-to-controller hash",
* CookieString | ClientNonce | ServerNonce)
* (with the HMAC key as its first argument)
*
* After a controller sends a successful AUTHCHALLENGE command, the
* next command sent on the connection must be an AUTHENTICATE command,
* and the only authentication string which that AUTHENTICATE command
* will accept is:
*
* HMAC-SHA256("Tor safe cookie authentication controller-to-server hash",
* CookieString | ClientNonce | ServerNonce)
*
*/
static std::vector<uint8_t> ComputeResponse(const std::string &key, const std::vector<uint8_t> &cookie, const std::vector<uint8_t> &clientNonce, const std::vector<uint8_t> &serverNonce)
{
CHMAC_SHA256 computeHash((const uint8_t*)key.data(), key.size());
std::vector<uint8_t> computedHash(CHMAC_SHA256::OUTPUT_SIZE, 0);
computeHash.Write(begin_ptr(cookie), cookie.size());
computeHash.Write(begin_ptr(clientNonce), clientNonce.size());
computeHash.Write(begin_ptr(serverNonce), serverNonce.size());
computeHash.Finalize(begin_ptr(computedHash));
return computedHash;
}
ExceptionOr<void> CryptoAlgorithmSHA1::digest(const CryptoAlgorithmParametersDeprecated&, const CryptoOperationData& data, VectorCallback&& callback, VoidCallback&& failureCallback)
{
auto digest = CryptoDigest::create(CryptoDigest::Algorithm::SHA_1);
if (!digest) {
failureCallback();
return { };
}
digest->addBytes(data.first, data.second);
callback(digest->computeHash());
return { };
}
// Find inside hash set
int HashSet_find(HashSet* h,const char* word,size_t len) {
int32_t hash=computeHash(word,len);
int64_t slot=hash&h->mask;
const Entry* e = &h->table[slot];
if (!Entry_isDeleted(e)) do {
if (e->hash == hash) return true;
slot = (slot + 1) & h->mask;
e = &h->table[slot];
} while (!Entry_isDeleted(e));
return false;
}
//------------------------------------------------------------------------------
inline unsigned int computeHash
(
const Vector2f& position,
const Domain& domain
)
{
return computeHash
(
computeCoordinate(position, domain),
domain.Dimensions.X
);
}
void DisassemblyData::recheck()
{
auto memLock = Memory::Lock();
if (!PSP_IsInited())
return;
u32 newHash = computeHash(address,size);
if (newHash != hash)
{
hash = newHash;
createLines();
}
}
static void addEntryToHashTable(HashTable* pHash, ZipEntry* pEntry)
{
unsigned int itemHash = computeHash(pEntry->fileName, pEntry->fileNameLen);
const ZipEntry* found;
found = (const ZipEntry*)mzHashTableLookup(pHash,
itemHash, pEntry, hashcmpZipEntry, true);
if (found != pEntry) {
LOGW("WARNING: duplicate entry '%.*s' in Zip\n",
found->fileNameLen, found->fileName);
/* keep going */
}
}
void DisassemblyFunction::recheck()
{
auto memLock = Memory::Lock();
if (!PSP_IsInited())
return;
u32 newHash = computeHash(address,size);
if (hash != newHash)
{
hash = newHash;
clear();
load();
}
}
SET_NODE *internalAdd(const ObjType &u) {
int hashval = computeHash(u);
// look for this object in the appropriate linked list
for (SET_NODE* p=hashTable[hashval]; p!=0; p=p->next)
if (p->u==u) return 0; // already a member
// create new node and stick at head of linked list
SET_NODE *sn = createNode(u);
sn->idx = currentSize;
sn->next = hashTable[hashval];
hashTable[hashval] = sn;
return sn;
}
int internalRemove(const ObjType &u) {
// returns index of extracted object, or -1 if not there.
int hashval = computeHash(u);
SET_NODE* sn = hashTable[hashval];
SET_NODE** pLast = &(hashTable[hashval]);
while (sn) {
if (sn->u == u) {
int idx = sn->idx;
*pLast = sn->next;
deleteNode(sn);
return idx;
}
pLast = &(sn->next);
sn = sn->next;
}
return -1;
}
/*
* The algorithm of RendezvousHash goes like this:
* Assuming we have 3 clusters with names and weights:
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* | n="cluster1" | n="cluster2" | n="cluster3" |
* | w=100 | w=400 | w=500 |
* ==============================================
* To prepare, we calculate a hash for each cluster based on its name:
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* | n="cluster1" | n="cluster2" | n="cluster3" |
* | w = 100 | w=400 | w=500 |
* | h = hash(n) | h = hash(n) | h = hash(n) |
* ==============================================
*
* When a key comes, we have to decide which cluster we want to assign it to:
* E.g., k = 10240
*
* For each cluster, we calculate a combined hash with the sum of key
* and the cluster's hash:
*
*
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* ...
* k | h=hash(n) | h = hash(n) | h=hash(n) |
* | ==============================================
* | |
* +-------------+----------------------------+
* |
* ch=hash(h + k)
* |
* v
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* | n="cluster1" | n="cluster2" | n="cluster3" |
* | w=100 | w=400 | w=500 |
* | h=hash(n) | h = hash(n) | h=hash(n) |
* |ch=hash(h+k) |ch = hash(h+k)|ch=hash(h+k) |
* ==============================================
*
* ch is now a random variable from 0 to max_int that follows
* uniform distribution,
* we need to scale it to a r.v. * from 0 to 1 by dividing it with max_int:
*
* scaledHash = ch / max_int
*
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* ....
* |ch=hash(h+k) |ch = hash(h+k)|ch=hash(h+k) |
* ==============================================
* |
* sh=ch/max_int
* |
* v
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* ....
* |ch=hash(h+k) |ch = hash(h+k)|ch=hash(h+k) |
* |sh=ch/max_int |sh=ch/max_int |sh=ch/max_int |
* ==============================================
*
* We also need to respect the weights, we have to scale it again with
* a function of its weight:
*
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* ....
* |sh=ch/max_int |sh=ch/max_int |sh=ch/max_int |
* ==============================================
* |
* |
* sw = pow(sh, 1/w)
* |
* V
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* ....
* |sh=ch/max_int |sh=ch/max_int |sh=ch/max_int |
* |sw=pow(sh,1/w)|sw=pow(sh,1/w)|sw=pow(sh,1/w)|
* ==============================================
*
* We now calculate who has the largest sw, that is the cluster that we are
* going to map k into:
* ==============================================
* | Cluster1 | Cluster2 | Cluster3 |
* ....
* |sw=pow(sh,1/w)|sw=pow(sh,1/w)|sw=pow(sh,1/w)|
* ==============================================
* |
* max(sw)
* |
* V
* Cluster
*
*/
size_t RendezvousHash::get(uint64_t key) const {
double maxWeight = -1.0;
size_t maxWeightId = 0;
for (size_t i = 0; i < nodes_.size(); ++i) {
auto& it = nodes_[i];
// combine the hash with the cluster together
double combinedHash = computeHash(it.first + key);
double scaledHash = combinedHash / std::numeric_limits<uint64_t>::max();
double scaledWeight = it.second > std::numeric_limits<double>::epsilon()
? std::pow(scaledHash, 1.0 / it.second)
: 0.0;
if (scaledWeight > maxWeight) {
maxWeightId = i;
maxWeight = scaledWeight;
}
}
return maxWeightId;
}
void CryptoAlgorithmSHA1::digest(Vector<uint8_t>&& message, VectorCallback&& callback, ExceptionCallback&& exceptionCallback, ScriptExecutionContext& context, WorkQueue& workQueue)
{
auto digest = CryptoDigest::create(CryptoDigest::Algorithm::SHA_1);
if (!digest) {
exceptionCallback(OperationError);
return;
}
context.ref();
workQueue.dispatch([digest = WTFMove(digest), message = WTFMove(message), callback = WTFMove(callback), &context]() mutable {
digest->addBytes(message.data(), message.size());
auto result = digest->computeHash();
context.postTask([callback = WTFMove(callback), result = WTFMove(result)](ScriptExecutionContext& context) {
callback(result);
context.deref();
});
});
}
void PipelineImpl::initColorState()
{
for(U i = 0; i < m_in.m_color.m_attachmentCount; ++i)
{
Attachment& out = m_cache.m_attachments[i];
const ColorAttachmentStateInfo& in = m_in.m_color.m_attachments[i];
out.m_srcBlendMethod = convertBlendMethod(in.m_srcBlendMethod);
out.m_dstBlendMethod = convertBlendMethod(in.m_dstBlendMethod);
switch(in.m_blendFunction)
{
case BlendFunction::ADD:
out.m_blendFunction = GL_FUNC_ADD;
break;
case BlendFunction::SUBTRACT:
out.m_blendFunction = GL_FUNC_SUBTRACT;
break;
case BlendFunction::REVERSE_SUBTRACT:
out.m_blendFunction = GL_FUNC_REVERSE_SUBTRACT;
break;
case BlendFunction::MIN:
out.m_blendFunction = GL_MIN;
break;
case BlendFunction::MAX:
out.m_blendFunction = GL_MAX;
break;
default:
ANKI_ASSERT(0);
}
out.m_channelWriteMask[0] = (in.m_channelWriteMask & ColorBit::RED) != 0;
out.m_channelWriteMask[1] = (in.m_channelWriteMask & ColorBit::GREEN) != 0;
out.m_channelWriteMask[2] = (in.m_channelWriteMask & ColorBit::BLUE) != 0;
out.m_channelWriteMask[3] = (in.m_channelWriteMask & ColorBit::ALPHA) != 0;
if(!(out.m_srcBlendMethod == GL_ONE && out.m_dstBlendMethod == GL_ZERO))
{
m_blendEnabled = true;
}
}
m_hashes.m_color = computeHash(&m_in.m_color, sizeof(m_in.m_color));
}
pt_value resolveSymbol(pt_context *context, char *name) {
extern pt_value UNDEF;
pt_context_node *node = context->tail;
int hash = computeHash(name);
while(node != NULL) {
pt_context_elem *elem = node->head;
while(elem != NULL) {
if(elem->hash == hash) {
return elem->value;
}
}
node = node->prev;
}
return UNDEF;
}
//------------------------------------------------------------------------------
void Solver::HashTable::Fill (unsigned int numParticles)
{
// clear all buckets
for (unsigned int i = 0; i < mDomain.Dimensions.X*mDomain.Dimensions.Y; i++)
{
mBuckets[i].clear();
}
// fill buckets
for (unsigned int i = 0; i < numParticles; i++)
{
unsigned int hash = computeHash
(
Vector2f(&mPositions[2*i]),
mDomain
);
mBuckets[hash].push_back(i);
}
}
/*
* Find a matching entry.
*
* Returns 0 if not found.
*/
ZipEntry dexZipFindEntry(const ZipArchive* pArchive, const char* entryName)
{
int nameLen = strlen(entryName);
unsigned int hash = computeHash(entryName, nameLen);
const int hashTableSize = pArchive->mHashTableSize;
int ent = hash & (hashTableSize-1);
while (pArchive->mHashTable[ent].name != NULL) {
if (pArchive->mHashTable[ent].nameLen == nameLen &&
memcmp(pArchive->mHashTable[ent].name, entryName, nameLen) == 0)
{
/* match */
return (ZipEntry)(long)(ent + kZipEntryAdj);
}
ent = (ent + 1) & (hashTableSize-1);
}
return NULL;
}
