blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
201
| content_id
stringlengths 40
40
| detected_licenses
listlengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 7
100
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 260
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 11.4k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 80
values | src_encoding
stringclasses 28
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 8
9.86M
| extension
stringclasses 52
values | content
stringlengths 8
9.86M
| authors
listlengths 1
1
| author
stringlengths 0
119
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
90a89e5d0eb2f92b397a9b56be62265bfa394993
|
ae5a3513aa321788cdba2152c997dfbde58579a1
|
/llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp
|
ffb5bc903f8573d4c34f3c52ece47133332629e5
|
[
"NCSA",
"LLVM-exception",
"Apache-2.0"
] |
permissive
|
djolertrk/llvm-metadataburn
|
d1c4cb783a872da141e32e61324af1d5adc13aff
|
84c171c3bd882a531e3f2c960b19eee0cf5bc557
|
refs/heads/main
| 2023-04-25T20:56:51.866409 | 2021-06-02T15:55:31 | 2021-06-02T15:55:31 | 373,075,312 | 2 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 99,870 |
cpp
|
//===-- PPCAsmPrinter.cpp - Print machine instrs to PowerPC assembly ------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file contains a printer that converts from our internal representation
// of machine-dependent LLVM code to PowerPC assembly language. This printer is
// the output mechanism used by `llc'.
//
// Documentation at http://developer.apple.com/documentation/DeveloperTools/
// Reference/Assembler/ASMIntroduction/chapter_1_section_1.html
//
//===----------------------------------------------------------------------===//
#include "MCTargetDesc/PPCInstPrinter.h"
#include "MCTargetDesc/PPCMCExpr.h"
#include "MCTargetDesc/PPCMCTargetDesc.h"
#include "MCTargetDesc/PPCPredicates.h"
#include "PPC.h"
#include "PPCInstrInfo.h"
#include "PPCMachineFunctionInfo.h"
#include "PPCSubtarget.h"
#include "PPCTargetMachine.h"
#include "PPCTargetStreamer.h"
#include "TargetInfo/PowerPCTargetInfo.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/Triple.h"
#include "llvm/ADT/Twine.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/CodeGen/MachineBasicBlock.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineModuleInfoImpls.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/StackMaps.h"
#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/GlobalVariable.h"
#include "llvm/IR/Module.h"
#include "llvm/MC/MCAsmInfo.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCDirectives.h"
#include "llvm/MC/MCExpr.h"
#include "llvm/MC/MCInst.h"
#include "llvm/MC/MCInstBuilder.h"
#include "llvm/MC/MCSectionELF.h"
#include "llvm/MC/MCSectionXCOFF.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbol.h"
#include "llvm/MC/MCSymbolELF.h"
#include "llvm/MC/MCSymbolXCOFF.h"
#include "llvm/MC/SectionKind.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/CodeGen.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/Process.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Transforms/Utils/ModuleUtils.h"
#include <algorithm>
#include <cassert>
#include <cstdint>
#include <memory>
#include <new>
using namespace llvm;
using namespace llvm::XCOFF;
#define DEBUG_TYPE "asmprinter"
// Specialize DenseMapInfo to allow
// std::pair<const MCSymbol *, MCSymbolRefExpr::VariantKind> in DenseMap.
// This specialization is needed here because that type is used as keys in the
// map representing TOC entries.
namespace llvm {
template <>
struct DenseMapInfo<std::pair<const MCSymbol *, MCSymbolRefExpr::VariantKind>> {
using TOCKey = std::pair<const MCSymbol *, MCSymbolRefExpr::VariantKind>;
static inline TOCKey getEmptyKey() {
return {nullptr, MCSymbolRefExpr::VariantKind::VK_None};
}
static inline TOCKey getTombstoneKey() {
return {nullptr, MCSymbolRefExpr::VariantKind::VK_Invalid};
}
static unsigned getHashValue(const TOCKey &PairVal) {
return detail::combineHashValue(
DenseMapInfo<const MCSymbol *>::getHashValue(PairVal.first),
DenseMapInfo<int>::getHashValue(PairVal.second));
}
static bool isEqual(const TOCKey &A, const TOCKey &B) { return A == B; }
};
} // end namespace llvm
namespace {
class PPCAsmPrinter : public AsmPrinter {
protected:
// For TLS on AIX, we need to be able to identify TOC entries of specific
// VariantKind so we can add the right relocations when we generate the
// entries. So each entry is represented by a pair of MCSymbol and
// VariantKind. For example, we need to be able to identify the following
// entry as a TLSGD entry so we can add the @m relocation:
// .tc .i[TC],i[TL]@m
// By default, VK_None is used for the VariantKind.
MapVector<std::pair<const MCSymbol *, MCSymbolRefExpr::VariantKind>,
MCSymbol *>
TOC;
const PPCSubtarget *Subtarget = nullptr;
StackMaps SM;
public:
explicit PPCAsmPrinter(TargetMachine &TM,
std::unique_ptr<MCStreamer> Streamer)
: AsmPrinter(TM, std::move(Streamer)), SM(*this) {}
StringRef getPassName() const override { return "PowerPC Assembly Printer"; }
MCSymbol *lookUpOrCreateTOCEntry(const MCSymbol *Sym,
MCSymbolRefExpr::VariantKind Kind =
MCSymbolRefExpr::VariantKind::VK_None);
bool doInitialization(Module &M) override {
if (!TOC.empty())
TOC.clear();
return AsmPrinter::doInitialization(M);
}
void emitInstruction(const MachineInstr *MI) override;
/// This function is for PrintAsmOperand and PrintAsmMemoryOperand,
/// invoked by EmitMSInlineAsmStr and EmitGCCInlineAsmStr only.
/// The \p MI would be INLINEASM ONLY.
void printOperand(const MachineInstr *MI, unsigned OpNo, raw_ostream &O);
void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &O) override;
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
const char *ExtraCode, raw_ostream &O) override;
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
const char *ExtraCode, raw_ostream &O) override;
void emitEndOfAsmFile(Module &M) override;
void LowerSTACKMAP(StackMaps &SM, const MachineInstr &MI);
void LowerPATCHPOINT(StackMaps &SM, const MachineInstr &MI);
void EmitTlsCall(const MachineInstr *MI, MCSymbolRefExpr::VariantKind VK);
bool runOnMachineFunction(MachineFunction &MF) override {
Subtarget = &MF.getSubtarget<PPCSubtarget>();
bool Changed = AsmPrinter::runOnMachineFunction(MF);
emitXRayTable();
return Changed;
}
};
/// PPCLinuxAsmPrinter - PowerPC assembly printer, customized for Linux
class PPCLinuxAsmPrinter : public PPCAsmPrinter {
public:
explicit PPCLinuxAsmPrinter(TargetMachine &TM,
std::unique_ptr<MCStreamer> Streamer)
: PPCAsmPrinter(TM, std::move(Streamer)) {}
StringRef getPassName() const override {
return "Linux PPC Assembly Printer";
}
void emitStartOfAsmFile(Module &M) override;
void emitEndOfAsmFile(Module &) override;
void emitFunctionEntryLabel() override;
void emitFunctionBodyStart() override;
void emitFunctionBodyEnd() override;
void emitInstruction(const MachineInstr *MI) override;
};
class PPCAIXAsmPrinter : public PPCAsmPrinter {
private:
/// Symbols lowered from ExternalSymbolSDNodes, we will need to emit extern
/// linkage for them in AIX.
SmallPtrSet<MCSymbol *, 8> ExtSymSDNodeSymbols;
/// A format indicator and unique trailing identifier to form part of the
/// sinit/sterm function names.
std::string FormatIndicatorAndUniqueModId;
// Record a list of GlobalAlias associated with a GlobalObject.
// This is used for AIX's extra-label-at-definition aliasing strategy.
DenseMap<const GlobalObject *, SmallVector<const GlobalAlias *, 1>>
GOAliasMap;
void emitTracebackTable();
SmallVector<const GlobalVariable *, 8> TOCDataGlobalVars;
void emitGlobalVariableHelper(const GlobalVariable *);
public:
PPCAIXAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
: PPCAsmPrinter(TM, std::move(Streamer)) {
if (MAI->isLittleEndian())
report_fatal_error(
"cannot create AIX PPC Assembly Printer for a little-endian target");
}
StringRef getPassName() const override { return "AIX PPC Assembly Printer"; }
bool doInitialization(Module &M) override;
void emitXXStructorList(const DataLayout &DL, const Constant *List,
bool IsCtor) override;
void SetupMachineFunction(MachineFunction &MF) override;
void emitGlobalVariable(const GlobalVariable *GV) override;
void emitFunctionDescriptor() override;
void emitFunctionEntryLabel() override;
void emitFunctionBodyEnd() override;
void emitEndOfAsmFile(Module &) override;
void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const override;
void emitInstruction(const MachineInstr *MI) override;
bool doFinalization(Module &M) override;
void emitTTypeReference(const GlobalValue *GV, unsigned Encoding) override;
};
} // end anonymous namespace
void PPCAsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
raw_ostream &O) {
// Computing the address of a global symbol, not calling it.
const GlobalValue *GV = MO.getGlobal();
getSymbol(GV)->print(O, MAI);
printOffset(MO.getOffset(), O);
}
void PPCAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
raw_ostream &O) {
const DataLayout &DL = getDataLayout();
const MachineOperand &MO = MI->getOperand(OpNo);
switch (MO.getType()) {
case MachineOperand::MO_Register: {
// The MI is INLINEASM ONLY and UseVSXReg is always false.
const char *RegName = PPCInstPrinter::getRegisterName(MO.getReg());
// Linux assembler (Others?) does not take register mnemonics.
// FIXME - What about special registers used in mfspr/mtspr?
O << PPCRegisterInfo::stripRegisterPrefix(RegName);
return;
}
case MachineOperand::MO_Immediate:
O << MO.getImm();
return;
case MachineOperand::MO_MachineBasicBlock:
MO.getMBB()->getSymbol()->print(O, MAI);
return;
case MachineOperand::MO_ConstantPoolIndex:
O << DL.getPrivateGlobalPrefix() << "CPI" << getFunctionNumber() << '_'
<< MO.getIndex();
return;
case MachineOperand::MO_BlockAddress:
GetBlockAddressSymbol(MO.getBlockAddress())->print(O, MAI);
return;
case MachineOperand::MO_GlobalAddress: {
PrintSymbolOperand(MO, O);
return;
}
default:
O << "<unknown operand type: " << (unsigned)MO.getType() << ">";
return;
}
}
/// PrintAsmOperand - Print out an operand for an inline asm expression.
///
bool PPCAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
const char *ExtraCode, raw_ostream &O) {
// Does this asm operand have a single letter operand modifier?
if (ExtraCode && ExtraCode[0]) {
if (ExtraCode[1] != 0) return true; // Unknown modifier.
switch (ExtraCode[0]) {
default:
// See if this is a generic print operand
return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, O);
case 'L': // Write second word of DImode reference.
// Verify that this operand has two consecutive registers.
if (!MI->getOperand(OpNo).isReg() ||
OpNo+1 == MI->getNumOperands() ||
!MI->getOperand(OpNo+1).isReg())
return true;
++OpNo; // Return the high-part.
break;
case 'I':
// Write 'i' if an integer constant, otherwise nothing. Used to print
// addi vs add, etc.
if (MI->getOperand(OpNo).isImm())
O << "i";
return false;
case 'x':
if(!MI->getOperand(OpNo).isReg())
return true;
// This operand uses VSX numbering.
// If the operand is a VMX register, convert it to a VSX register.
Register Reg = MI->getOperand(OpNo).getReg();
if (PPCInstrInfo::isVRRegister(Reg))
Reg = PPC::VSX32 + (Reg - PPC::V0);
else if (PPCInstrInfo::isVFRegister(Reg))
Reg = PPC::VSX32 + (Reg - PPC::VF0);
const char *RegName;
RegName = PPCInstPrinter::getRegisterName(Reg);
RegName = PPCRegisterInfo::stripRegisterPrefix(RegName);
O << RegName;
return false;
}
}
printOperand(MI, OpNo, O);
return false;
}
// At the moment, all inline asm memory operands are a single register.
// In any case, the output of this routine should always be just one
// assembler operand.
bool PPCAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
const char *ExtraCode,
raw_ostream &O) {
if (ExtraCode && ExtraCode[0]) {
if (ExtraCode[1] != 0) return true; // Unknown modifier.
switch (ExtraCode[0]) {
default: return true; // Unknown modifier.
case 'L': // A memory reference to the upper word of a double word op.
O << getDataLayout().getPointerSize() << "(";
printOperand(MI, OpNo, O);
O << ")";
return false;
case 'y': // A memory reference for an X-form instruction
O << "0, ";
printOperand(MI, OpNo, O);
return false;
case 'U': // Print 'u' for update form.
case 'X': // Print 'x' for indexed form.
// FIXME: Currently for PowerPC memory operands are always loaded
// into a register, so we never get an update or indexed form.
// This is bad even for offset forms, since even if we know we
// have a value in -16(r1), we will generate a load into r<n>
// and then load from 0(r<n>). Until that issue is fixed,
// tolerate 'U' and 'X' but don't output anything.
assert(MI->getOperand(OpNo).isReg());
return false;
}
}
assert(MI->getOperand(OpNo).isReg());
O << "0(";
printOperand(MI, OpNo, O);
O << ")";
return false;
}
/// lookUpOrCreateTOCEntry -- Given a symbol, look up whether a TOC entry
/// exists for it. If not, create one. Then return a symbol that references
/// the TOC entry.
MCSymbol *
PPCAsmPrinter::lookUpOrCreateTOCEntry(const MCSymbol *Sym,
MCSymbolRefExpr::VariantKind Kind) {
MCSymbol *&TOCEntry = TOC[{Sym, Kind}];
if (!TOCEntry)
TOCEntry = createTempSymbol("C");
return TOCEntry;
}
void PPCAsmPrinter::emitEndOfAsmFile(Module &M) {
emitStackMaps(SM);
}
void PPCAsmPrinter::LowerSTACKMAP(StackMaps &SM, const MachineInstr &MI) {
unsigned NumNOPBytes = MI.getOperand(1).getImm();
auto &Ctx = OutStreamer->getContext();
MCSymbol *MILabel = Ctx.createTempSymbol();
OutStreamer->emitLabel(MILabel);
SM.recordStackMap(*MILabel, MI);
assert(NumNOPBytes % 4 == 0 && "Invalid number of NOP bytes requested!");
// Scan ahead to trim the shadow.
const MachineBasicBlock &MBB = *MI.getParent();
MachineBasicBlock::const_iterator MII(MI);
++MII;
while (NumNOPBytes > 0) {
if (MII == MBB.end() || MII->isCall() ||
MII->getOpcode() == PPC::DBG_VALUE ||
MII->getOpcode() == TargetOpcode::PATCHPOINT ||
MII->getOpcode() == TargetOpcode::STACKMAP)
break;
++MII;
NumNOPBytes -= 4;
}
// Emit nops.
for (unsigned i = 0; i < NumNOPBytes; i += 4)
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
}
// Lower a patchpoint of the form:
// [<def>], <id>, <numBytes>, <target>, <numArgs>
void PPCAsmPrinter::LowerPATCHPOINT(StackMaps &SM, const MachineInstr &MI) {
auto &Ctx = OutStreamer->getContext();
MCSymbol *MILabel = Ctx.createTempSymbol();
OutStreamer->emitLabel(MILabel);
SM.recordPatchPoint(*MILabel, MI);
PatchPointOpers Opers(&MI);
unsigned EncodedBytes = 0;
const MachineOperand &CalleeMO = Opers.getCallTarget();
if (CalleeMO.isImm()) {
int64_t CallTarget = CalleeMO.getImm();
if (CallTarget) {
assert((CallTarget & 0xFFFFFFFFFFFF) == CallTarget &&
"High 16 bits of call target should be zero.");
Register ScratchReg = MI.getOperand(Opers.getNextScratchIdx()).getReg();
EncodedBytes = 0;
// Materialize the jump address:
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI8)
.addReg(ScratchReg)
.addImm((CallTarget >> 32) & 0xFFFF));
++EncodedBytes;
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::RLDIC)
.addReg(ScratchReg)
.addReg(ScratchReg)
.addImm(32).addImm(16));
++EncodedBytes;
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ORIS8)
.addReg(ScratchReg)
.addReg(ScratchReg)
.addImm((CallTarget >> 16) & 0xFFFF));
++EncodedBytes;
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ORI8)
.addReg(ScratchReg)
.addReg(ScratchReg)
.addImm(CallTarget & 0xFFFF));
// Save the current TOC pointer before the remote call.
int TOCSaveOffset = Subtarget->getFrameLowering()->getTOCSaveOffset();
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::STD)
.addReg(PPC::X2)
.addImm(TOCSaveOffset)
.addReg(PPC::X1));
++EncodedBytes;
// If we're on ELFv1, then we need to load the actual function pointer
// from the function descriptor.
if (!Subtarget->isELFv2ABI()) {
// Load the new TOC pointer and the function address, but not r11
// (needing this is rare, and loading it here would prevent passing it
// via a 'nest' parameter.
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
.addReg(PPC::X2)
.addImm(8)
.addReg(ScratchReg));
++EncodedBytes;
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
.addReg(ScratchReg)
.addImm(0)
.addReg(ScratchReg));
++EncodedBytes;
}
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTCTR8)
.addReg(ScratchReg));
++EncodedBytes;
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BCTRL8));
++EncodedBytes;
// Restore the TOC pointer after the call.
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
.addReg(PPC::X2)
.addImm(TOCSaveOffset)
.addReg(PPC::X1));
++EncodedBytes;
}
} else if (CalleeMO.isGlobal()) {
const GlobalValue *GValue = CalleeMO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymVar = MCSymbolRefExpr::create(MOSymbol, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL8_NOP)
.addExpr(SymVar));
EncodedBytes += 2;
}
// Each instruction is 4 bytes.
EncodedBytes *= 4;
// Emit padding.
unsigned NumBytes = Opers.getNumPatchBytes();
assert(NumBytes >= EncodedBytes &&
"Patchpoint can't request size less than the length of a call.");
assert((NumBytes - EncodedBytes) % 4 == 0 &&
"Invalid number of NOP bytes requested!");
for (unsigned i = EncodedBytes; i < NumBytes; i += 4)
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
}
/// This helper function creates the TlsGetAddr MCSymbol for AIX. We will
/// create the csect and use the qual-name symbol instead of creating just the
/// external symbol.
static MCSymbol *createMCSymbolForTlsGetAddr(MCContext &Ctx) {
return Ctx
.getXCOFFSection(".__tls_get_addr", SectionKind::getText(),
XCOFF::CsectProperties(XCOFF::XMC_PR, XCOFF::XTY_ER))
->getQualNameSymbol();
}
/// EmitTlsCall -- Given a GETtls[ld]ADDR[32] instruction, print a
/// call to __tls_get_addr to the current output stream.
void PPCAsmPrinter::EmitTlsCall(const MachineInstr *MI,
MCSymbolRefExpr::VariantKind VK) {
MCSymbolRefExpr::VariantKind Kind = MCSymbolRefExpr::VK_None;
unsigned Opcode = PPC::BL8_NOP_TLS;
assert(MI->getNumOperands() >= 3 && "Expecting at least 3 operands from MI");
if (MI->getOperand(2).getTargetFlags() == PPCII::MO_GOT_TLSGD_PCREL_FLAG ||
MI->getOperand(2).getTargetFlags() == PPCII::MO_GOT_TLSLD_PCREL_FLAG) {
Kind = MCSymbolRefExpr::VK_PPC_NOTOC;
Opcode = PPC::BL8_NOTOC_TLS;
}
const Module *M = MF->getFunction().getParent();
assert(MI->getOperand(0).isReg() &&
((Subtarget->isPPC64() && MI->getOperand(0).getReg() == PPC::X3) ||
(!Subtarget->isPPC64() && MI->getOperand(0).getReg() == PPC::R3)) &&
"GETtls[ld]ADDR[32] must define GPR3");
assert(MI->getOperand(1).isReg() &&
((Subtarget->isPPC64() && MI->getOperand(1).getReg() == PPC::X3) ||
(!Subtarget->isPPC64() && MI->getOperand(1).getReg() == PPC::R3)) &&
"GETtls[ld]ADDR[32] must read GPR3");
if (Subtarget->isAIXABI()) {
// On AIX, the variable offset should already be in R4 and the region handle
// should already be in R3.
// For TLSGD, which currently is the only supported access model, we only
// need to generate an absolute branch to .__tls_get_addr.
Register VarOffsetReg = Subtarget->isPPC64() ? PPC::X4 : PPC::R4;
(void)VarOffsetReg;
assert(MI->getOperand(2).isReg() &&
MI->getOperand(2).getReg() == VarOffsetReg &&
"GETtls[ld]ADDR[32] must read GPR4");
MCSymbol *TlsGetAddr = createMCSymbolForTlsGetAddr(OutContext);
const MCExpr *TlsRef = MCSymbolRefExpr::create(
TlsGetAddr, MCSymbolRefExpr::VK_None, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BLA).addExpr(TlsRef));
return;
}
MCSymbol *TlsGetAddr = OutContext.getOrCreateSymbol("__tls_get_addr");
if (Subtarget->is32BitELFABI() && isPositionIndependent())
Kind = MCSymbolRefExpr::VK_PLT;
const MCExpr *TlsRef =
MCSymbolRefExpr::create(TlsGetAddr, Kind, OutContext);
// Add 32768 offset to the symbol so we follow up the latest GOT/PLT ABI.
if (Kind == MCSymbolRefExpr::VK_PLT && Subtarget->isSecurePlt() &&
M->getPICLevel() == PICLevel::BigPIC)
TlsRef = MCBinaryExpr::createAdd(
TlsRef, MCConstantExpr::create(32768, OutContext), OutContext);
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymVar = MCSymbolRefExpr::create(MOSymbol, VK, OutContext);
EmitToStreamer(*OutStreamer,
MCInstBuilder(Subtarget->isPPC64() ? Opcode
: (unsigned)PPC::BL_TLS)
.addExpr(TlsRef)
.addExpr(SymVar));
}
/// Map a machine operand for a TOC pseudo-machine instruction to its
/// corresponding MCSymbol.
static MCSymbol *getMCSymbolForTOCPseudoMO(const MachineOperand &MO,
AsmPrinter &AP) {
switch (MO.getType()) {
case MachineOperand::MO_GlobalAddress:
return AP.getSymbol(MO.getGlobal());
case MachineOperand::MO_ConstantPoolIndex:
return AP.GetCPISymbol(MO.getIndex());
case MachineOperand::MO_JumpTableIndex:
return AP.GetJTISymbol(MO.getIndex());
case MachineOperand::MO_BlockAddress:
return AP.GetBlockAddressSymbol(MO.getBlockAddress());
default:
llvm_unreachable("Unexpected operand type to get symbol.");
}
}
/// EmitInstruction -- Print out a single PowerPC MI in Darwin syntax to
/// the current output stream.
///
void PPCAsmPrinter::emitInstruction(const MachineInstr *MI) {
MCInst TmpInst;
const bool IsPPC64 = Subtarget->isPPC64();
const bool IsAIX = Subtarget->isAIXABI();
const Module *M = MF->getFunction().getParent();
PICLevel::Level PL = M->getPICLevel();
#ifndef NDEBUG
// Validate that SPE and FPU are mutually exclusive in codegen
if (!MI->isInlineAsm()) {
for (const MachineOperand &MO: MI->operands()) {
if (MO.isReg()) {
Register Reg = MO.getReg();
if (Subtarget->hasSPE()) {
if (PPC::F4RCRegClass.contains(Reg) ||
PPC::F8RCRegClass.contains(Reg) ||
PPC::VFRCRegClass.contains(Reg) ||
PPC::VRRCRegClass.contains(Reg) ||
PPC::VSFRCRegClass.contains(Reg) ||
PPC::VSSRCRegClass.contains(Reg)
)
llvm_unreachable("SPE targets cannot have FPRegs!");
} else {
if (PPC::SPERCRegClass.contains(Reg))
llvm_unreachable("SPE register found in FPU-targeted code!");
}
}
}
}
#endif
auto getTOCRelocAdjustedExprForXCOFF = [this](const MCExpr *Expr,
ptrdiff_t OriginalOffset) {
// Apply an offset to the TOC-based expression such that the adjusted
// notional offset from the TOC base (to be encoded into the instruction's D
// or DS field) is the signed 16-bit truncation of the original notional
// offset from the TOC base.
// This is consistent with the treatment used both by XL C/C++ and
// by AIX ld -r.
ptrdiff_t Adjustment =
OriginalOffset - llvm::SignExtend32<16>(OriginalOffset);
return MCBinaryExpr::createAdd(
Expr, MCConstantExpr::create(-Adjustment, OutContext), OutContext);
};
auto getTOCEntryLoadingExprForXCOFF =
[IsPPC64, getTOCRelocAdjustedExprForXCOFF,
this](const MCSymbol *MOSymbol, const MCExpr *Expr,
MCSymbolRefExpr::VariantKind VK =
MCSymbolRefExpr::VariantKind::VK_None) -> const MCExpr * {
const unsigned EntryByteSize = IsPPC64 ? 8 : 4;
const auto TOCEntryIter = TOC.find({MOSymbol, VK});
assert(TOCEntryIter != TOC.end() &&
"Could not find the TOC entry for this symbol.");
const ptrdiff_t EntryDistanceFromTOCBase =
(TOCEntryIter - TOC.begin()) * EntryByteSize;
constexpr int16_t PositiveTOCRange = INT16_MAX;
if (EntryDistanceFromTOCBase > PositiveTOCRange)
return getTOCRelocAdjustedExprForXCOFF(Expr, EntryDistanceFromTOCBase);
return Expr;
};
auto GetVKForMO = [&](const MachineOperand &MO) {
// For GD TLS access on AIX, we have two TOC entries for the symbol (one for
// the variable offset and the other for the region handle). They are
// differentiated by MO_TLSGD_FLAG and MO_TLSGDM_FLAG.
if (MO.getTargetFlags() & PPCII::MO_TLSGDM_FLAG)
return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGDM;
if (MO.getTargetFlags() & PPCII::MO_TLSGD_FLAG)
return MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGD;
return MCSymbolRefExpr::VariantKind::VK_None;
};
// Lower multi-instruction pseudo operations.
switch (MI->getOpcode()) {
default: break;
case TargetOpcode::DBG_VALUE:
llvm_unreachable("Should be handled target independently");
case TargetOpcode::STACKMAP:
return LowerSTACKMAP(SM, *MI);
case TargetOpcode::PATCHPOINT:
return LowerPATCHPOINT(SM, *MI);
case PPC::MoveGOTtoLR: {
// Transform %lr = MoveGOTtoLR
// Into this: bl _GLOBAL_OFFSET_TABLE_@local-4
// _GLOBAL_OFFSET_TABLE_@local-4 (instruction preceding
// _GLOBAL_OFFSET_TABLE_) has exactly one instruction:
// blrl
// This will return the pointer to _GLOBAL_OFFSET_TABLE_@local
MCSymbol *GOTSymbol =
OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
const MCExpr *OffsExpr =
MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol,
MCSymbolRefExpr::VK_PPC_LOCAL,
OutContext),
MCConstantExpr::create(4, OutContext),
OutContext);
// Emit the 'bl'.
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL).addExpr(OffsExpr));
return;
}
case PPC::MovePCtoLR:
case PPC::MovePCtoLR8: {
// Transform %lr = MovePCtoLR
// Into this, where the label is the PIC base:
// bl L1$pb
// L1$pb:
MCSymbol *PICBase = MF->getPICBaseSymbol();
// Emit the 'bl'.
EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::BL)
// FIXME: We would like an efficient form for this, so we
// don't have to do a lot of extra uniquing.
.addExpr(MCSymbolRefExpr::create(PICBase, OutContext)));
// Emit the label.
OutStreamer->emitLabel(PICBase);
return;
}
case PPC::UpdateGBR: {
// Transform %rd = UpdateGBR(%rt, %ri)
// Into: lwz %rt, .L0$poff - .L0$pb(%ri)
// add %rd, %rt, %ri
// or into (if secure plt mode is on):
// addis r30, r30, {.LTOC,_GLOBAL_OFFSET_TABLE} - .L0$pb@ha
// addi r30, r30, {.LTOC,_GLOBAL_OFFSET_TABLE} - .L0$pb@l
// Get the offset from the GOT Base Register to the GOT
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
if (Subtarget->isSecurePlt() && isPositionIndependent() ) {
unsigned PICR = TmpInst.getOperand(0).getReg();
MCSymbol *BaseSymbol = OutContext.getOrCreateSymbol(
M->getPICLevel() == PICLevel::SmallPIC ? "_GLOBAL_OFFSET_TABLE_"
: ".LTOC");
const MCExpr *PB =
MCSymbolRefExpr::create(MF->getPICBaseSymbol(), OutContext);
const MCExpr *DeltaExpr = MCBinaryExpr::createSub(
MCSymbolRefExpr::create(BaseSymbol, OutContext), PB, OutContext);
const MCExpr *DeltaHi = PPCMCExpr::createHa(DeltaExpr, OutContext);
EmitToStreamer(
*OutStreamer,
MCInstBuilder(PPC::ADDIS).addReg(PICR).addReg(PICR).addExpr(DeltaHi));
const MCExpr *DeltaLo = PPCMCExpr::createLo(DeltaExpr, OutContext);
EmitToStreamer(
*OutStreamer,
MCInstBuilder(PPC::ADDI).addReg(PICR).addReg(PICR).addExpr(DeltaLo));
return;
} else {
MCSymbol *PICOffset =
MF->getInfo<PPCFunctionInfo>()->getPICOffsetSymbol(*MF);
TmpInst.setOpcode(PPC::LWZ);
const MCExpr *Exp =
MCSymbolRefExpr::create(PICOffset, MCSymbolRefExpr::VK_None, OutContext);
const MCExpr *PB =
MCSymbolRefExpr::create(MF->getPICBaseSymbol(),
MCSymbolRefExpr::VK_None,
OutContext);
const MCOperand TR = TmpInst.getOperand(1);
const MCOperand PICR = TmpInst.getOperand(0);
// Step 1: lwz %rt, .L$poff - .L$pb(%ri)
TmpInst.getOperand(1) =
MCOperand::createExpr(MCBinaryExpr::createSub(Exp, PB, OutContext));
TmpInst.getOperand(0) = TR;
TmpInst.getOperand(2) = PICR;
EmitToStreamer(*OutStreamer, TmpInst);
TmpInst.setOpcode(PPC::ADD4);
TmpInst.getOperand(0) = PICR;
TmpInst.getOperand(1) = TR;
TmpInst.getOperand(2) = PICR;
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
}
case PPC::LWZtoc: {
// Transform %rN = LWZtoc @op1, %r2
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to LWZ.
TmpInst.setOpcode(PPC::LWZ);
const MachineOperand &MO = MI->getOperand(1);
assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
"Invalid operand for LWZtoc.");
// Map the operand to its corresponding MCSymbol.
const MCSymbol *const MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
// Create a reference to the GOT entry for the symbol. The GOT entry will be
// synthesized later.
if (PL == PICLevel::SmallPIC && !IsAIX) {
const MCExpr *Exp =
MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_GOT,
OutContext);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
MCSymbolRefExpr::VariantKind VK = GetVKForMO(MO);
// Otherwise, use the TOC. 'TOCEntry' is a label used to reference the
// storage allocated in the TOC which contains the address of
// 'MOSymbol'. Said TOC entry will be synthesized later.
MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol, VK);
const MCExpr *Exp =
MCSymbolRefExpr::create(TOCEntry, MCSymbolRefExpr::VK_None, OutContext);
// AIX uses the label directly as the lwz displacement operand for
// references into the toc section. The displacement value will be generated
// relative to the toc-base.
if (IsAIX) {
assert(
TM.getCodeModel() == CodeModel::Small &&
"This pseudo should only be selected for 32-bit small code model.");
Exp = getTOCEntryLoadingExprForXCOFF(MOSymbol, Exp, VK);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
// Print MO for better readability
if (isVerbose())
OutStreamer->GetCommentOS() << MO << '\n';
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
// Create an explicit subtract expression between the local symbol and
// '.LTOC' to manifest the toc-relative offset.
const MCExpr *PB = MCSymbolRefExpr::create(
OutContext.getOrCreateSymbol(Twine(".LTOC")), OutContext);
Exp = MCBinaryExpr::createSub(Exp, PB, OutContext);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::ADDItoc: {
assert(IsAIX && TM.getCodeModel() == CodeModel::Small &&
"Operand only valid in AIX 32 bit mode");
// Transform %rN = ADDItoc @op1, %r2.
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to load address.
TmpInst.setOpcode(PPC::LA);
const MachineOperand &MO = MI->getOperand(1);
assert(MO.isGlobal() && "Invalid operand for ADDItoc.");
// Map the operand to its corresponding MCSymbol.
const MCSymbol *const MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
const MCExpr *Exp =
MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_None, OutContext);
TmpInst.getOperand(1) = TmpInst.getOperand(2);
TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::LDtocJTI:
case PPC::LDtocCPT:
case PPC::LDtocBA:
case PPC::LDtoc: {
// Transform %x3 = LDtoc @min1, %x2
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to LD.
TmpInst.setOpcode(PPC::LD);
const MachineOperand &MO = MI->getOperand(1);
assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
"Invalid operand!");
// Map the operand to its corresponding MCSymbol.
const MCSymbol *const MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
MCSymbolRefExpr::VariantKind VK = GetVKForMO(MO);
// Map the machine operand to its corresponding MCSymbol, then map the
// global address operand to be a reference to the TOC entry we will
// synthesize later.
MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol, VK);
MCSymbolRefExpr::VariantKind VKExpr =
IsAIX ? MCSymbolRefExpr::VK_None : MCSymbolRefExpr::VK_PPC_TOC;
const MCExpr *Exp = MCSymbolRefExpr::create(TOCEntry, VKExpr, OutContext);
TmpInst.getOperand(1) = MCOperand::createExpr(
IsAIX ? getTOCEntryLoadingExprForXCOFF(MOSymbol, Exp, VK) : Exp);
// Print MO for better readability
if (isVerbose() && IsAIX)
OutStreamer->GetCommentOS() << MO << '\n';
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::ADDIStocHA: {
assert((IsAIX && !IsPPC64 && TM.getCodeModel() == CodeModel::Large) &&
"This pseudo should only be selected for 32-bit large code model on"
" AIX.");
// Transform %rd = ADDIStocHA %rA, @sym(%r2)
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to ADDIS.
TmpInst.setOpcode(PPC::ADDIS);
const MachineOperand &MO = MI->getOperand(2);
assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
"Invalid operand for ADDIStocHA.");
// Map the machine operand to its corresponding MCSymbol.
MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
MCSymbolRefExpr::VariantKind VK = GetVKForMO(MO);
// Always use TOC on AIX. Map the global address operand to be a reference
// to the TOC entry we will synthesize later. 'TOCEntry' is a label used to
// reference the storage allocated in the TOC which contains the address of
// 'MOSymbol'.
MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol, VK);
const MCExpr *Exp = MCSymbolRefExpr::create(TOCEntry,
MCSymbolRefExpr::VK_PPC_U,
OutContext);
TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::LWZtocL: {
assert(IsAIX && !IsPPC64 && TM.getCodeModel() == CodeModel::Large &&
"This pseudo should only be selected for 32-bit large code model on"
" AIX.");
// Transform %rd = LWZtocL @sym, %rs.
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to lwz.
TmpInst.setOpcode(PPC::LWZ);
const MachineOperand &MO = MI->getOperand(1);
assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
"Invalid operand for LWZtocL.");
// Map the machine operand to its corresponding MCSymbol.
MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
MCSymbolRefExpr::VariantKind VK = GetVKForMO(MO);
// Always use TOC on AIX. Map the global address operand to be a reference
// to the TOC entry we will synthesize later. 'TOCEntry' is a label used to
// reference the storage allocated in the TOC which contains the address of
// 'MOSymbol'.
MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol, VK);
const MCExpr *Exp = MCSymbolRefExpr::create(TOCEntry,
MCSymbolRefExpr::VK_PPC_L,
OutContext);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::ADDIStocHA8: {
// Transform %xd = ADDIStocHA8 %x2, @sym
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to ADDIS8. If the global address is the address of
// an external symbol, is a jump table address, is a block address, or is a
// constant pool index with large code model enabled, then generate a TOC
// entry and reference that. Otherwise, reference the symbol directly.
TmpInst.setOpcode(PPC::ADDIS8);
const MachineOperand &MO = MI->getOperand(2);
assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
"Invalid operand for ADDIStocHA8!");
const MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
MCSymbolRefExpr::VariantKind VK = GetVKForMO(MO);
const bool GlobalToc =
MO.isGlobal() && Subtarget->isGVIndirectSymbol(MO.getGlobal());
if (GlobalToc || MO.isJTI() || MO.isBlockAddress() ||
(MO.isCPI() && TM.getCodeModel() == CodeModel::Large))
MOSymbol = lookUpOrCreateTOCEntry(MOSymbol, VK);
VK = IsAIX ? MCSymbolRefExpr::VK_PPC_U : MCSymbolRefExpr::VK_PPC_TOC_HA;
const MCExpr *Exp =
MCSymbolRefExpr::create(MOSymbol, VK, OutContext);
if (!MO.isJTI() && MO.getOffset())
Exp = MCBinaryExpr::createAdd(Exp,
MCConstantExpr::create(MO.getOffset(),
OutContext),
OutContext);
TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::LDtocL: {
// Transform %xd = LDtocL @sym, %xs
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to LD. If the global address is the address of
// an external symbol, is a jump table address, is a block address, or is
// a constant pool index with large code model enabled, then generate a
// TOC entry and reference that. Otherwise, reference the symbol directly.
TmpInst.setOpcode(PPC::LD);
const MachineOperand &MO = MI->getOperand(1);
assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() ||
MO.isBlockAddress()) &&
"Invalid operand for LDtocL!");
LLVM_DEBUG(assert(
(!MO.isGlobal() || Subtarget->isGVIndirectSymbol(MO.getGlobal())) &&
"LDtocL used on symbol that could be accessed directly is "
"invalid. Must match ADDIStocHA8."));
const MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
MCSymbolRefExpr::VariantKind VK = GetVKForMO(MO);
if (!MO.isCPI() || TM.getCodeModel() == CodeModel::Large)
MOSymbol = lookUpOrCreateTOCEntry(MOSymbol, VK);
VK = IsAIX ? MCSymbolRefExpr::VK_PPC_L : MCSymbolRefExpr::VK_PPC_TOC_LO;
const MCExpr *Exp =
MCSymbolRefExpr::create(MOSymbol, VK, OutContext);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::ADDItocL: {
// Transform %xd = ADDItocL %xs, @sym
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to ADDI8. If the global address is external, then
// generate a TOC entry and reference that. Otherwise, reference the
// symbol directly.
TmpInst.setOpcode(PPC::ADDI8);
const MachineOperand &MO = MI->getOperand(2);
assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL.");
LLVM_DEBUG(assert(
!(MO.isGlobal() && Subtarget->isGVIndirectSymbol(MO.getGlobal())) &&
"Interposable definitions must use indirect access."));
const MCExpr *Exp =
MCSymbolRefExpr::create(getMCSymbolForTOCPseudoMO(MO, *this),
MCSymbolRefExpr::VK_PPC_TOC_LO, OutContext);
TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::ADDISgotTprelHA: {
// Transform: %xd = ADDISgotTprelHA %x2, @sym
// Into: %xd = ADDIS8 %x2, sym@got@tlsgd@ha
assert(IsPPC64 && "Not supported for 32-bit PowerPC");
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTprel =
MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TPREL_HA,
OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addExpr(SymGotTprel));
return;
}
case PPC::LDgotTprelL:
case PPC::LDgotTprelL32: {
// Transform %xd = LDgotTprelL @sym, %xs
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
// Change the opcode to LD.
TmpInst.setOpcode(IsPPC64 ? PPC::LD : PPC::LWZ);
const MachineOperand &MO = MI->getOperand(1);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *Exp = MCSymbolRefExpr::create(
MOSymbol, IsPPC64 ? MCSymbolRefExpr::VK_PPC_GOT_TPREL_LO
: MCSymbolRefExpr::VK_PPC_GOT_TPREL,
OutContext);
TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
EmitToStreamer(*OutStreamer, TmpInst);
return;
}
case PPC::PPC32PICGOT: {
MCSymbol *GOTSymbol = OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
MCSymbol *GOTRef = OutContext.createTempSymbol();
MCSymbol *NextInstr = OutContext.createTempSymbol();
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::BL)
// FIXME: We would like an efficient form for this, so we don't have to do
// a lot of extra uniquing.
.addExpr(MCSymbolRefExpr::create(NextInstr, OutContext)));
const MCExpr *OffsExpr =
MCBinaryExpr::createSub(MCSymbolRefExpr::create(GOTSymbol, OutContext),
MCSymbolRefExpr::create(GOTRef, OutContext),
OutContext);
OutStreamer->emitLabel(GOTRef);
OutStreamer->emitValue(OffsExpr, 4);
OutStreamer->emitLabel(NextInstr);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR)
.addReg(MI->getOperand(0).getReg()));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LWZ)
.addReg(MI->getOperand(1).getReg())
.addImm(0)
.addReg(MI->getOperand(0).getReg()));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADD4)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addReg(MI->getOperand(0).getReg()));
return;
}
case PPC::PPC32GOT: {
MCSymbol *GOTSymbol =
OutContext.getOrCreateSymbol(StringRef("_GLOBAL_OFFSET_TABLE_"));
const MCExpr *SymGotTlsL = MCSymbolRefExpr::create(
GOTSymbol, MCSymbolRefExpr::VK_PPC_LO, OutContext);
const MCExpr *SymGotTlsHA = MCSymbolRefExpr::create(
GOTSymbol, MCSymbolRefExpr::VK_PPC_HA, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LI)
.addReg(MI->getOperand(0).getReg())
.addExpr(SymGotTlsL));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(0).getReg())
.addExpr(SymGotTlsHA));
return;
}
case PPC::ADDIStlsgdHA: {
// Transform: %xd = ADDIStlsgdHA %x2, @sym
// Into: %xd = ADDIS8 %x2, sym@got@tlsgd@ha
assert(IsPPC64 && "Not supported for 32-bit PowerPC");
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTlsGD =
MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSGD_HA,
OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addExpr(SymGotTlsGD));
return;
}
case PPC::ADDItlsgdL:
// Transform: %xd = ADDItlsgdL %xs, @sym
// Into: %xd = ADDI8 %xs, sym@got@tlsgd@l
case PPC::ADDItlsgdL32: {
// Transform: %rd = ADDItlsgdL32 %rs, @sym
// Into: %rd = ADDI %rs, sym@got@tlsgd
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTlsGD = MCSymbolRefExpr::create(
MOSymbol, IsPPC64 ? MCSymbolRefExpr::VK_PPC_GOT_TLSGD_LO
: MCSymbolRefExpr::VK_PPC_GOT_TLSGD,
OutContext);
EmitToStreamer(*OutStreamer,
MCInstBuilder(IsPPC64 ? PPC::ADDI8 : PPC::ADDI)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addExpr(SymGotTlsGD));
return;
}
case PPC::GETtlsADDR:
// Transform: %x3 = GETtlsADDR %x3, @sym
// Into: BL8_NOP_TLS __tls_get_addr(sym at tlsgd)
case PPC::GETtlsADDRPCREL:
case PPC::GETtlsADDR32AIX:
case PPC::GETtlsADDR64AIX:
// Transform: %r3 = GETtlsADDRNNAIX %r3, %r4 (for NN == 32/64).
// Into: BLA .__tls_get_addr()
// Unlike on Linux, there is no symbol or relocation needed for this call.
case PPC::GETtlsADDR32: {
// Transform: %r3 = GETtlsADDR32 %r3, @sym
// Into: BL_TLS __tls_get_addr(sym at tlsgd)@PLT
EmitTlsCall(MI, MCSymbolRefExpr::VK_PPC_TLSGD);
return;
}
case PPC::ADDIStlsldHA: {
// Transform: %xd = ADDIStlsldHA %x2, @sym
// Into: %xd = ADDIS8 %x2, sym@got@tlsld@ha
assert(IsPPC64 && "Not supported for 32-bit PowerPC");
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTlsLD =
MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_GOT_TLSLD_HA,
OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS8)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addExpr(SymGotTlsLD));
return;
}
case PPC::ADDItlsldL:
// Transform: %xd = ADDItlsldL %xs, @sym
// Into: %xd = ADDI8 %xs, sym@got@tlsld@l
case PPC::ADDItlsldL32: {
// Transform: %rd = ADDItlsldL32 %rs, @sym
// Into: %rd = ADDI %rs, sym@got@tlsld
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymGotTlsLD = MCSymbolRefExpr::create(
MOSymbol, IsPPC64 ? MCSymbolRefExpr::VK_PPC_GOT_TLSLD_LO
: MCSymbolRefExpr::VK_PPC_GOT_TLSLD,
OutContext);
EmitToStreamer(*OutStreamer,
MCInstBuilder(IsPPC64 ? PPC::ADDI8 : PPC::ADDI)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addExpr(SymGotTlsLD));
return;
}
case PPC::GETtlsldADDR:
// Transform: %x3 = GETtlsldADDR %x3, @sym
// Into: BL8_NOP_TLS __tls_get_addr(sym at tlsld)
case PPC::GETtlsldADDRPCREL:
case PPC::GETtlsldADDR32: {
// Transform: %r3 = GETtlsldADDR32 %r3, @sym
// Into: BL_TLS __tls_get_addr(sym at tlsld)@PLT
EmitTlsCall(MI, MCSymbolRefExpr::VK_PPC_TLSLD);
return;
}
case PPC::ADDISdtprelHA:
// Transform: %xd = ADDISdtprelHA %xs, @sym
// Into: %xd = ADDIS8 %xs, sym@dtprel@ha
case PPC::ADDISdtprelHA32: {
// Transform: %rd = ADDISdtprelHA32 %rs, @sym
// Into: %rd = ADDIS %rs, sym@dtprel@ha
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymDtprel =
MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_HA,
OutContext);
EmitToStreamer(
*OutStreamer,
MCInstBuilder(IsPPC64 ? PPC::ADDIS8 : PPC::ADDIS)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addExpr(SymDtprel));
return;
}
case PPC::PADDIdtprel: {
// Transform: %rd = PADDIdtprel %rs, @sym
// Into: %rd = PADDI8 %rs, sym@dtprel
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymDtprel = MCSymbolRefExpr::create(
MOSymbol, MCSymbolRefExpr::VK_DTPREL, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::PADDI8)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addExpr(SymDtprel));
return;
}
case PPC::ADDIdtprelL:
// Transform: %xd = ADDIdtprelL %xs, @sym
// Into: %xd = ADDI8 %xs, sym@dtprel@l
case PPC::ADDIdtprelL32: {
// Transform: %rd = ADDIdtprelL32 %rs, @sym
// Into: %rd = ADDI %rs, sym@dtprel@l
const MachineOperand &MO = MI->getOperand(2);
const GlobalValue *GValue = MO.getGlobal();
MCSymbol *MOSymbol = getSymbol(GValue);
const MCExpr *SymDtprel =
MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_PPC_DTPREL_LO,
OutContext);
EmitToStreamer(*OutStreamer,
MCInstBuilder(IsPPC64 ? PPC::ADDI8 : PPC::ADDI)
.addReg(MI->getOperand(0).getReg())
.addReg(MI->getOperand(1).getReg())
.addExpr(SymDtprel));
return;
}
case PPC::MFOCRF:
case PPC::MFOCRF8:
if (!Subtarget->hasMFOCRF()) {
// Transform: %r3 = MFOCRF %cr7
// Into: %r3 = MFCR ;; cr7
unsigned NewOpcode =
MI->getOpcode() == PPC::MFOCRF ? PPC::MFCR : PPC::MFCR8;
OutStreamer->AddComment(PPCInstPrinter::
getRegisterName(MI->getOperand(1).getReg()));
EmitToStreamer(*OutStreamer, MCInstBuilder(NewOpcode)
.addReg(MI->getOperand(0).getReg()));
return;
}
break;
case PPC::MTOCRF:
case PPC::MTOCRF8:
if (!Subtarget->hasMFOCRF()) {
// Transform: %cr7 = MTOCRF %r3
// Into: MTCRF mask, %r3 ;; cr7
unsigned NewOpcode =
MI->getOpcode() == PPC::MTOCRF ? PPC::MTCRF : PPC::MTCRF8;
unsigned Mask = 0x80 >> OutContext.getRegisterInfo()
->getEncodingValue(MI->getOperand(0).getReg());
OutStreamer->AddComment(PPCInstPrinter::
getRegisterName(MI->getOperand(0).getReg()));
EmitToStreamer(*OutStreamer, MCInstBuilder(NewOpcode)
.addImm(Mask)
.addReg(MI->getOperand(1).getReg()));
return;
}
break;
case PPC::LD:
case PPC::STD:
case PPC::LWA_32:
case PPC::LWA: {
// Verify alignment is legal, so we don't create relocations
// that can't be supported.
unsigned OpNum = (MI->getOpcode() == PPC::STD) ? 2 : 1;
const MachineOperand &MO = MI->getOperand(OpNum);
if (MO.isGlobal()) {
const DataLayout &DL = MO.getGlobal()->getParent()->getDataLayout();
if (MO.getGlobal()->getPointerAlignment(DL) < 4)
llvm_unreachable("Global must be word-aligned for LD, STD, LWA!");
}
// Now process the instruction normally.
break;
}
}
LowerPPCMachineInstrToMCInst(MI, TmpInst, *this);
EmitToStreamer(*OutStreamer, TmpInst);
}
void PPCLinuxAsmPrinter::emitInstruction(const MachineInstr *MI) {
if (!Subtarget->isPPC64())
return PPCAsmPrinter::emitInstruction(MI);
switch (MI->getOpcode()) {
default:
return PPCAsmPrinter::emitInstruction(MI);
case TargetOpcode::PATCHABLE_FUNCTION_ENTER: {
// .begin:
// b .end # lis 0, FuncId[16..32]
// nop # li 0, FuncId[0..15]
// std 0, -8(1)
// mflr 0
// bl __xray_FunctionEntry
// mtlr 0
// .end:
//
// Update compiler-rt/lib/xray/xray_powerpc64.cc accordingly when number
// of instructions change.
MCSymbol *BeginOfSled = OutContext.createTempSymbol();
MCSymbol *EndOfSled = OutContext.createTempSymbol();
OutStreamer->emitLabel(BeginOfSled);
EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::B).addExpr(
MCSymbolRefExpr::create(EndOfSled, OutContext)));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
EmitToStreamer(
*OutStreamer,
MCInstBuilder(PPC::STD).addReg(PPC::X0).addImm(-8).addReg(PPC::X1));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));
EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::BL8_NOP)
.addExpr(MCSymbolRefExpr::create(
OutContext.getOrCreateSymbol("__xray_FunctionEntry"),
OutContext)));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR8).addReg(PPC::X0));
OutStreamer->emitLabel(EndOfSled);
recordSled(BeginOfSled, *MI, SledKind::FUNCTION_ENTER, 2);
break;
}
case TargetOpcode::PATCHABLE_RET: {
unsigned RetOpcode = MI->getOperand(0).getImm();
MCInst RetInst;
RetInst.setOpcode(RetOpcode);
for (const auto &MO : llvm::drop_begin(MI->operands())) {
MCOperand MCOp;
if (LowerPPCMachineOperandToMCOperand(MO, MCOp, *this))
RetInst.addOperand(MCOp);
}
bool IsConditional;
if (RetOpcode == PPC::BCCLR) {
IsConditional = true;
} else if (RetOpcode == PPC::TCRETURNdi8 || RetOpcode == PPC::TCRETURNri8 ||
RetOpcode == PPC::TCRETURNai8) {
break;
} else if (RetOpcode == PPC::BLR8 || RetOpcode == PPC::TAILB8) {
IsConditional = false;
} else {
EmitToStreamer(*OutStreamer, RetInst);
break;
}
MCSymbol *FallthroughLabel;
if (IsConditional) {
// Before:
// bgtlr cr0
//
// After:
// ble cr0, .end
// .p2align 3
// .begin:
// blr # lis 0, FuncId[16..32]
// nop # li 0, FuncId[0..15]
// std 0, -8(1)
// mflr 0
// bl __xray_FunctionExit
// mtlr 0
// blr
// .end:
//
// Update compiler-rt/lib/xray/xray_powerpc64.cc accordingly when number
// of instructions change.
FallthroughLabel = OutContext.createTempSymbol();
EmitToStreamer(
*OutStreamer,
MCInstBuilder(PPC::BCC)
.addImm(PPC::InvertPredicate(
static_cast<PPC::Predicate>(MI->getOperand(1).getImm())))
.addReg(MI->getOperand(2).getReg())
.addExpr(MCSymbolRefExpr::create(FallthroughLabel, OutContext)));
RetInst = MCInst();
RetInst.setOpcode(PPC::BLR8);
}
// .p2align 3
// .begin:
// b(lr)? # lis 0, FuncId[16..32]
// nop # li 0, FuncId[0..15]
// std 0, -8(1)
// mflr 0
// bl __xray_FunctionExit
// mtlr 0
// b(lr)?
//
// Update compiler-rt/lib/xray/xray_powerpc64.cc accordingly when number
// of instructions change.
OutStreamer->emitCodeAlignment(8);
MCSymbol *BeginOfSled = OutContext.createTempSymbol();
OutStreamer->emitLabel(BeginOfSled);
EmitToStreamer(*OutStreamer, RetInst);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::NOP));
EmitToStreamer(
*OutStreamer,
MCInstBuilder(PPC::STD).addReg(PPC::X0).addImm(-8).addReg(PPC::X1));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MFLR8).addReg(PPC::X0));
EmitToStreamer(*OutStreamer,
MCInstBuilder(PPC::BL8_NOP)
.addExpr(MCSymbolRefExpr::create(
OutContext.getOrCreateSymbol("__xray_FunctionExit"),
OutContext)));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::MTLR8).addReg(PPC::X0));
EmitToStreamer(*OutStreamer, RetInst);
if (IsConditional)
OutStreamer->emitLabel(FallthroughLabel);
recordSled(BeginOfSled, *MI, SledKind::FUNCTION_EXIT, 2);
break;
}
case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
llvm_unreachable("PATCHABLE_FUNCTION_EXIT should never be emitted");
case TargetOpcode::PATCHABLE_TAIL_CALL:
// TODO: Define a trampoline `__xray_FunctionTailExit` and differentiate a
// normal function exit from a tail exit.
llvm_unreachable("Tail call is handled in the normal case. See comments "
"around this assert.");
}
}
void PPCLinuxAsmPrinter::emitStartOfAsmFile(Module &M) {
if (static_cast<const PPCTargetMachine &>(TM).isELFv2ABI()) {
PPCTargetStreamer *TS =
static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
if (TS)
TS->emitAbiVersion(2);
}
if (static_cast<const PPCTargetMachine &>(TM).isPPC64() ||
!isPositionIndependent())
return AsmPrinter::emitStartOfAsmFile(M);
if (M.getPICLevel() == PICLevel::SmallPIC)
return AsmPrinter::emitStartOfAsmFile(M);
OutStreamer->SwitchSection(OutContext.getELFSection(
".got2", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC));
MCSymbol *TOCSym = OutContext.getOrCreateSymbol(Twine(".LTOC"));
MCSymbol *CurrentPos = OutContext.createTempSymbol();
OutStreamer->emitLabel(CurrentPos);
// The GOT pointer points to the middle of the GOT, in order to reference the
// entire 64kB range. 0x8000 is the midpoint.
const MCExpr *tocExpr =
MCBinaryExpr::createAdd(MCSymbolRefExpr::create(CurrentPos, OutContext),
MCConstantExpr::create(0x8000, OutContext),
OutContext);
OutStreamer->emitAssignment(TOCSym, tocExpr);
OutStreamer->SwitchSection(getObjFileLowering().getTextSection());
}
void PPCLinuxAsmPrinter::emitFunctionEntryLabel() {
// linux/ppc32 - Normal entry label.
if (!Subtarget->isPPC64() &&
(!isPositionIndependent() ||
MF->getFunction().getParent()->getPICLevel() == PICLevel::SmallPIC))
return AsmPrinter::emitFunctionEntryLabel();
if (!Subtarget->isPPC64()) {
const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
if (PPCFI->usesPICBase() && !Subtarget->isSecurePlt()) {
MCSymbol *RelocSymbol = PPCFI->getPICOffsetSymbol(*MF);
MCSymbol *PICBase = MF->getPICBaseSymbol();
OutStreamer->emitLabel(RelocSymbol);
const MCExpr *OffsExpr =
MCBinaryExpr::createSub(
MCSymbolRefExpr::create(OutContext.getOrCreateSymbol(Twine(".LTOC")),
OutContext),
MCSymbolRefExpr::create(PICBase, OutContext),
OutContext);
OutStreamer->emitValue(OffsExpr, 4);
OutStreamer->emitLabel(CurrentFnSym);
return;
} else
return AsmPrinter::emitFunctionEntryLabel();
}
// ELFv2 ABI - Normal entry label.
if (Subtarget->isELFv2ABI()) {
// In the Large code model, we allow arbitrary displacements between
// the text section and its associated TOC section. We place the
// full 8-byte offset to the TOC in memory immediately preceding
// the function global entry point.
if (TM.getCodeModel() == CodeModel::Large
&& !MF->getRegInfo().use_empty(PPC::X2)) {
const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
MCSymbol *GlobalEPSymbol = PPCFI->getGlobalEPSymbol(*MF);
const MCExpr *TOCDeltaExpr =
MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
MCSymbolRefExpr::create(GlobalEPSymbol,
OutContext),
OutContext);
OutStreamer->emitLabel(PPCFI->getTOCOffsetSymbol(*MF));
OutStreamer->emitValue(TOCDeltaExpr, 8);
}
return AsmPrinter::emitFunctionEntryLabel();
}
// Emit an official procedure descriptor.
MCSectionSubPair Current = OutStreamer->getCurrentSection();
MCSectionELF *Section = OutStreamer->getContext().getELFSection(
".opd", ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
OutStreamer->SwitchSection(Section);
OutStreamer->emitLabel(CurrentFnSym);
OutStreamer->emitValueToAlignment(8);
MCSymbol *Symbol1 = CurrentFnSymForSize;
// Generates a R_PPC64_ADDR64 (from FK_DATA_8) relocation for the function
// entry point.
OutStreamer->emitValue(MCSymbolRefExpr::create(Symbol1, OutContext),
8 /*size*/);
MCSymbol *Symbol2 = OutContext.getOrCreateSymbol(StringRef(".TOC."));
// Generates a R_PPC64_TOC relocation for TOC base insertion.
OutStreamer->emitValue(
MCSymbolRefExpr::create(Symbol2, MCSymbolRefExpr::VK_PPC_TOCBASE, OutContext),
8/*size*/);
// Emit a null environment pointer.
OutStreamer->emitIntValue(0, 8 /* size */);
OutStreamer->SwitchSection(Current.first, Current.second);
}
void PPCLinuxAsmPrinter::emitEndOfAsmFile(Module &M) {
const DataLayout &DL = getDataLayout();
bool isPPC64 = DL.getPointerSizeInBits() == 64;
PPCTargetStreamer *TS =
static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
if (!TOC.empty()) {
const char *Name = isPPC64 ? ".toc" : ".got2";
MCSectionELF *Section = OutContext.getELFSection(
Name, ELF::SHT_PROGBITS, ELF::SHF_WRITE | ELF::SHF_ALLOC);
OutStreamer->SwitchSection(Section);
if (!isPPC64)
OutStreamer->emitValueToAlignment(4);
for (const auto &TOCMapPair : TOC) {
const MCSymbol *const TOCEntryTarget = TOCMapPair.first.first;
MCSymbol *const TOCEntryLabel = TOCMapPair.second;
OutStreamer->emitLabel(TOCEntryLabel);
if (isPPC64 && TS != nullptr)
TS->emitTCEntry(*TOCEntryTarget, TOCMapPair.first.second);
else
OutStreamer->emitSymbolValue(TOCEntryTarget, 4);
}
}
PPCAsmPrinter::emitEndOfAsmFile(M);
}
/// EmitFunctionBodyStart - Emit a global entry point prefix for ELFv2.
void PPCLinuxAsmPrinter::emitFunctionBodyStart() {
// In the ELFv2 ABI, in functions that use the TOC register, we need to
// provide two entry points. The ABI guarantees that when calling the
// local entry point, r2 is set up by the caller to contain the TOC base
// for this function, and when calling the global entry point, r12 is set
// up by the caller to hold the address of the global entry point. We
// thus emit a prefix sequence along the following lines:
//
// func:
// .Lfunc_gepNN:
// # global entry point
// addis r2,r12,(.TOC.-.Lfunc_gepNN)@ha
// addi r2,r2,(.TOC.-.Lfunc_gepNN)@l
// .Lfunc_lepNN:
// .localentry func, .Lfunc_lepNN-.Lfunc_gepNN
// # local entry point, followed by function body
//
// For the Large code model, we create
//
// .Lfunc_tocNN:
// .quad .TOC.-.Lfunc_gepNN # done by EmitFunctionEntryLabel
// func:
// .Lfunc_gepNN:
// # global entry point
// ld r2,.Lfunc_tocNN-.Lfunc_gepNN(r12)
// add r2,r2,r12
// .Lfunc_lepNN:
// .localentry func, .Lfunc_lepNN-.Lfunc_gepNN
// # local entry point, followed by function body
//
// This ensures we have r2 set up correctly while executing the function
// body, no matter which entry point is called.
const PPCFunctionInfo *PPCFI = MF->getInfo<PPCFunctionInfo>();
const bool UsesX2OrR2 = !MF->getRegInfo().use_empty(PPC::X2) ||
!MF->getRegInfo().use_empty(PPC::R2);
const bool PCrelGEPRequired = Subtarget->isUsingPCRelativeCalls() &&
UsesX2OrR2 && PPCFI->usesTOCBasePtr();
const bool NonPCrelGEPRequired = !Subtarget->isUsingPCRelativeCalls() &&
Subtarget->isELFv2ABI() && UsesX2OrR2;
// Only do all that if the function uses R2 as the TOC pointer
// in the first place. We don't need the global entry point if the
// function uses R2 as an allocatable register.
if (NonPCrelGEPRequired || PCrelGEPRequired) {
// Note: The logic here must be synchronized with the code in the
// branch-selection pass which sets the offset of the first block in the
// function. This matters because it affects the alignment.
MCSymbol *GlobalEntryLabel = PPCFI->getGlobalEPSymbol(*MF);
OutStreamer->emitLabel(GlobalEntryLabel);
const MCSymbolRefExpr *GlobalEntryLabelExp =
MCSymbolRefExpr::create(GlobalEntryLabel, OutContext);
if (TM.getCodeModel() != CodeModel::Large) {
MCSymbol *TOCSymbol = OutContext.getOrCreateSymbol(StringRef(".TOC."));
const MCExpr *TOCDeltaExpr =
MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCSymbol, OutContext),
GlobalEntryLabelExp, OutContext);
const MCExpr *TOCDeltaHi = PPCMCExpr::createHa(TOCDeltaExpr, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDIS)
.addReg(PPC::X2)
.addReg(PPC::X12)
.addExpr(TOCDeltaHi));
const MCExpr *TOCDeltaLo = PPCMCExpr::createLo(TOCDeltaExpr, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADDI)
.addReg(PPC::X2)
.addReg(PPC::X2)
.addExpr(TOCDeltaLo));
} else {
MCSymbol *TOCOffset = PPCFI->getTOCOffsetSymbol(*MF);
const MCExpr *TOCOffsetDeltaExpr =
MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCOffset, OutContext),
GlobalEntryLabelExp, OutContext);
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::LD)
.addReg(PPC::X2)
.addExpr(TOCOffsetDeltaExpr)
.addReg(PPC::X12));
EmitToStreamer(*OutStreamer, MCInstBuilder(PPC::ADD8)
.addReg(PPC::X2)
.addReg(PPC::X2)
.addReg(PPC::X12));
}
MCSymbol *LocalEntryLabel = PPCFI->getLocalEPSymbol(*MF);
OutStreamer->emitLabel(LocalEntryLabel);
const MCSymbolRefExpr *LocalEntryLabelExp =
MCSymbolRefExpr::create(LocalEntryLabel, OutContext);
const MCExpr *LocalOffsetExp =
MCBinaryExpr::createSub(LocalEntryLabelExp,
GlobalEntryLabelExp, OutContext);
PPCTargetStreamer *TS =
static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
if (TS)
TS->emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym), LocalOffsetExp);
} else if (Subtarget->isUsingPCRelativeCalls()) {
// When generating the entry point for a function we have a few scenarios
// based on whether or not that function uses R2 and whether or not that
// function makes calls (or is a leaf function).
// 1) A leaf function that does not use R2 (or treats it as callee-saved
// and preserves it). In this case st_other=0 and both
// the local and global entry points for the function are the same.
// No special entry point code is required.
// 2) A function uses the TOC pointer R2. This function may or may not have
// calls. In this case st_other=[2,6] and the global and local entry
// points are different. Code to correctly setup the TOC pointer in R2
// is put between the global and local entry points. This case is
// covered by the if statatement above.
// 3) A function does not use the TOC pointer R2 but does have calls.
// In this case st_other=1 since we do not know whether or not any
// of the callees clobber R2. This case is dealt with in this else if
// block. Tail calls are considered calls and the st_other should also
// be set to 1 in that case as well.
// 4) The function does not use the TOC pointer but R2 is used inside
// the function. In this case st_other=1 once again.
// 5) This function uses inline asm. We mark R2 as reserved if the function
// has inline asm as we have to assume that it may be used.
if (MF->getFrameInfo().hasCalls() || MF->getFrameInfo().hasTailCall() ||
MF->hasInlineAsm() || (!PPCFI->usesTOCBasePtr() && UsesX2OrR2)) {
PPCTargetStreamer *TS =
static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
if (TS)
TS->emitLocalEntry(cast<MCSymbolELF>(CurrentFnSym),
MCConstantExpr::create(1, OutContext));
}
}
}
/// EmitFunctionBodyEnd - Print the traceback table before the .size
/// directive.
///
void PPCLinuxAsmPrinter::emitFunctionBodyEnd() {
// Only the 64-bit target requires a traceback table. For now,
// we only emit the word of zeroes that GDB requires to find
// the end of the function, and zeroes for the eight-byte
// mandatory fields.
// FIXME: We should fill in the eight-byte mandatory fields as described in
// the PPC64 ELF ABI (this is a low-priority item because GDB does not
// currently make use of these fields).
if (Subtarget->isPPC64()) {
OutStreamer->emitIntValue(0, 4/*size*/);
OutStreamer->emitIntValue(0, 8/*size*/);
}
}
void PPCAIXAsmPrinter::emitLinkage(const GlobalValue *GV,
MCSymbol *GVSym) const {
assert(MAI->hasVisibilityOnlyWithLinkage() &&
"AIX's linkage directives take a visibility setting.");
MCSymbolAttr LinkageAttr = MCSA_Invalid;
switch (GV->getLinkage()) {
case GlobalValue::ExternalLinkage:
LinkageAttr = GV->isDeclaration() ? MCSA_Extern : MCSA_Global;
break;
case GlobalValue::LinkOnceAnyLinkage:
case GlobalValue::LinkOnceODRLinkage:
case GlobalValue::WeakAnyLinkage:
case GlobalValue::WeakODRLinkage:
case GlobalValue::ExternalWeakLinkage:
LinkageAttr = MCSA_Weak;
break;
case GlobalValue::AvailableExternallyLinkage:
LinkageAttr = MCSA_Extern;
break;
case GlobalValue::PrivateLinkage:
return;
case GlobalValue::InternalLinkage:
assert(GV->getVisibility() == GlobalValue::DefaultVisibility &&
"InternalLinkage should not have other visibility setting.");
LinkageAttr = MCSA_LGlobal;
break;
case GlobalValue::AppendingLinkage:
llvm_unreachable("Should never emit this");
case GlobalValue::CommonLinkage:
llvm_unreachable("CommonLinkage of XCOFF should not come to this path");
}
assert(LinkageAttr != MCSA_Invalid && "LinkageAttr should not MCSA_Invalid.");
MCSymbolAttr VisibilityAttr = MCSA_Invalid;
if (!TM.getIgnoreXCOFFVisibility()) {
switch (GV->getVisibility()) {
// TODO: "exported" and "internal" Visibility needs to go here.
case GlobalValue::DefaultVisibility:
break;
case GlobalValue::HiddenVisibility:
VisibilityAttr = MAI->getHiddenVisibilityAttr();
break;
case GlobalValue::ProtectedVisibility:
VisibilityAttr = MAI->getProtectedVisibilityAttr();
break;
}
}
OutStreamer->emitXCOFFSymbolLinkageWithVisibility(GVSym, LinkageAttr,
VisibilityAttr);
}
void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
// Setup CurrentFnDescSym and its containing csect.
MCSectionXCOFF *FnDescSec =
cast<MCSectionXCOFF>(getObjFileLowering().getSectionForFunctionDescriptor(
&MF.getFunction(), TM));
FnDescSec->setAlignment(Align(Subtarget->isPPC64() ? 8 : 4));
CurrentFnDescSym = FnDescSec->getQualNameSymbol();
return AsmPrinter::SetupMachineFunction(MF);
}
void PPCAIXAsmPrinter::emitFunctionBodyEnd() {
if (!TM.getXCOFFTracebackTable())
return;
emitTracebackTable();
}
void PPCAIXAsmPrinter::emitTracebackTable() {
// Create a symbol for the end of function.
MCSymbol *FuncEnd = createTempSymbol(MF->getName());
OutStreamer->emitLabel(FuncEnd);
OutStreamer->AddComment("Traceback table begin");
// Begin with a fullword of zero.
OutStreamer->emitIntValueInHexWithPadding(0, 4 /*size*/);
SmallString<128> CommentString;
raw_svector_ostream CommentOS(CommentString);
auto EmitComment = [&]() {
OutStreamer->AddComment(CommentOS.str());
CommentString.clear();
};
auto EmitCommentAndValue = [&](uint64_t Value, int Size) {
EmitComment();
OutStreamer->emitIntValueInHexWithPadding(Value, Size);
};
unsigned int Version = 0;
CommentOS << "Version = " << Version;
EmitCommentAndValue(Version, 1);
// There is a lack of information in the IR to assist with determining the
// source language. AIX exception handling mechanism would only search for
// personality routine and LSDA area when such language supports exception
// handling. So to be conservatively correct and allow runtime to do its job,
// we need to set it to C++ for now.
TracebackTable::LanguageID LanguageIdentifier =
TracebackTable::CPlusPlus; // C++
CommentOS << "Language = "
<< getNameForTracebackTableLanguageId(LanguageIdentifier);
EmitCommentAndValue(LanguageIdentifier, 1);
// This is only populated for the third and fourth bytes.
uint32_t FirstHalfOfMandatoryField = 0;
// Emit the 3rd byte of the mandatory field.
// We always set traceback offset bit to true.
FirstHalfOfMandatoryField |= TracebackTable::HasTraceBackTableOffsetMask;
const PPCFunctionInfo *FI = MF->getInfo<PPCFunctionInfo>();
const MachineRegisterInfo &MRI = MF->getRegInfo();
// Check the function uses floating-point processor instructions or not
for (unsigned Reg = PPC::F0; Reg <= PPC::F31; ++Reg) {
if (MRI.isPhysRegUsed(Reg)) {
FirstHalfOfMandatoryField |= TracebackTable::IsFloatingPointPresentMask;
break;
}
}
#define GENBOOLCOMMENT(Prefix, V, Field) \
CommentOS << (Prefix) << ((V) & (TracebackTable::Field##Mask) ? "+" : "-") \
<< #Field
#define GENVALUECOMMENT(PrefixAndName, V, Field) \
CommentOS << (PrefixAndName) << " = " \
<< static_cast<unsigned>(((V) & (TracebackTable::Field##Mask)) >> \
(TracebackTable::Field##Shift))
GENBOOLCOMMENT("", FirstHalfOfMandatoryField, IsGlobaLinkage);
GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsOutOfLineEpilogOrPrologue);
EmitComment();
GENBOOLCOMMENT("", FirstHalfOfMandatoryField, HasTraceBackTableOffset);
GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsInternalProcedure);
EmitComment();
GENBOOLCOMMENT("", FirstHalfOfMandatoryField, HasControlledStorage);
GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsTOCless);
EmitComment();
GENBOOLCOMMENT("", FirstHalfOfMandatoryField, IsFloatingPointPresent);
EmitComment();
GENBOOLCOMMENT("", FirstHalfOfMandatoryField,
IsFloatingPointOperationLogOrAbortEnabled);
EmitComment();
OutStreamer->emitIntValueInHexWithPadding(
(FirstHalfOfMandatoryField & 0x0000ff00) >> 8, 1);
// Set the 4th byte of the mandatory field.
FirstHalfOfMandatoryField |= TracebackTable::IsFunctionNamePresentMask;
static_assert(XCOFF::AllocRegNo == 31, "Unexpected register usage!");
if (MRI.isPhysRegUsed(Subtarget->isPPC64() ? PPC::X31 : PPC::R31))
FirstHalfOfMandatoryField |= TracebackTable::IsAllocaUsedMask;
const SmallVectorImpl<Register> &MustSaveCRs = FI->getMustSaveCRs();
if (!MustSaveCRs.empty())
FirstHalfOfMandatoryField |= TracebackTable::IsCRSavedMask;
if (FI->mustSaveLR())
FirstHalfOfMandatoryField |= TracebackTable::IsLRSavedMask;
GENBOOLCOMMENT("", FirstHalfOfMandatoryField, IsInterruptHandler);
GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsFunctionNamePresent);
GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsAllocaUsed);
EmitComment();
GENVALUECOMMENT("OnConditionDirective", FirstHalfOfMandatoryField,
OnConditionDirective);
GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsCRSaved);
GENBOOLCOMMENT(", ", FirstHalfOfMandatoryField, IsLRSaved);
EmitComment();
OutStreamer->emitIntValueInHexWithPadding((FirstHalfOfMandatoryField & 0xff),
1);
// Set the 5th byte of mandatory field.
uint32_t SecondHalfOfMandatoryField = 0;
// Always store back chain.
SecondHalfOfMandatoryField |= TracebackTable::IsBackChainStoredMask;
uint32_t FPRSaved = 0;
for (unsigned Reg = PPC::F14; Reg <= PPC::F31; ++Reg) {
if (MRI.isPhysRegModified(Reg)) {
FPRSaved = PPC::F31 - Reg + 1;
break;
}
}
SecondHalfOfMandatoryField |= (FPRSaved << TracebackTable::FPRSavedShift) &
TracebackTable::FPRSavedMask;
GENBOOLCOMMENT("", SecondHalfOfMandatoryField, IsBackChainStored);
GENBOOLCOMMENT(", ", SecondHalfOfMandatoryField, IsFixup);
GENVALUECOMMENT(", NumOfFPRsSaved", SecondHalfOfMandatoryField, FPRSaved);
EmitComment();
OutStreamer->emitIntValueInHexWithPadding(
(SecondHalfOfMandatoryField & 0xff000000) >> 24, 1);
// Set the 6th byte of mandatory field.
bool ShouldEmitEHBlock = TargetLoweringObjectFileXCOFF::ShouldEmitEHBlock(MF);
if (ShouldEmitEHBlock)
SecondHalfOfMandatoryField |= TracebackTable::HasExtensionTableMask;
uint32_t GPRSaved = 0;
// X13 is reserved under 64-bit environment.
unsigned GPRBegin = Subtarget->isPPC64() ? PPC::X14 : PPC::R13;
unsigned GPREnd = Subtarget->isPPC64() ? PPC::X31 : PPC::R31;
for (unsigned Reg = GPRBegin; Reg <= GPREnd; ++Reg) {
if (MRI.isPhysRegModified(Reg)) {
GPRSaved = GPREnd - Reg + 1;
break;
}
}
SecondHalfOfMandatoryField |= (GPRSaved << TracebackTable::GPRSavedShift) &
TracebackTable::GPRSavedMask;
GENBOOLCOMMENT("", SecondHalfOfMandatoryField, HasVectorInfo);
GENBOOLCOMMENT(", ", SecondHalfOfMandatoryField, HasExtensionTable);
GENVALUECOMMENT(", NumOfGPRsSaved", SecondHalfOfMandatoryField, GPRSaved);
EmitComment();
OutStreamer->emitIntValueInHexWithPadding(
(SecondHalfOfMandatoryField & 0x00ff0000) >> 16, 1);
// Set the 7th byte of mandatory field.
uint32_t NumberOfFixedPara = FI->getFixedParamNum();
SecondHalfOfMandatoryField |=
(NumberOfFixedPara << TracebackTable::NumberOfFixedParmsShift) &
TracebackTable::NumberOfFixedParmsMask;
GENVALUECOMMENT("NumberOfFixedParms", SecondHalfOfMandatoryField,
NumberOfFixedParms);
EmitComment();
OutStreamer->emitIntValueInHexWithPadding(
(SecondHalfOfMandatoryField & 0x0000ff00) >> 8, 1);
// Set the 8th byte of mandatory field.
// Always set parameter on stack.
SecondHalfOfMandatoryField |= TracebackTable::HasParmsOnStackMask;
uint32_t NumberOfFPPara = FI->getFloatingPointParamNum();
SecondHalfOfMandatoryField |=
(NumberOfFPPara << TracebackTable::NumberOfFloatingPointParmsShift) &
TracebackTable::NumberOfFloatingPointParmsMask;
GENVALUECOMMENT("NumberOfFPParms", SecondHalfOfMandatoryField,
NumberOfFloatingPointParms);
GENBOOLCOMMENT(", ", SecondHalfOfMandatoryField, HasParmsOnStack);
EmitComment();
OutStreamer->emitIntValueInHexWithPadding(SecondHalfOfMandatoryField & 0xff,
1);
// Generate the optional fields of traceback table.
// Parameter type.
if (NumberOfFixedPara || NumberOfFPPara) {
assert((SecondHalfOfMandatoryField & TracebackTable::HasVectorInfoMask) ==
0 &&
"VectorInfo has not been implemented.");
uint32_t ParaType = FI->getParameterType();
CommentOS << "Parameter type = "
<< XCOFF::parseParmsType(ParaType,
NumberOfFixedPara + NumberOfFPPara);
EmitComment();
OutStreamer->emitIntValueInHexWithPadding(ParaType, sizeof(ParaType));
}
// Traceback table offset.
OutStreamer->AddComment("Function size");
if (FirstHalfOfMandatoryField & TracebackTable::HasTraceBackTableOffsetMask) {
MCSymbol *FuncSectSym = getObjFileLowering().getFunctionEntryPointSymbol(
&(MF->getFunction()), TM);
OutStreamer->emitAbsoluteSymbolDiff(FuncEnd, FuncSectSym, 4);
}
// Since we unset the Int_Handler.
if (FirstHalfOfMandatoryField & TracebackTable::IsInterruptHandlerMask)
report_fatal_error("Hand_Mask not implement yet");
if (FirstHalfOfMandatoryField & TracebackTable::HasControlledStorageMask)
report_fatal_error("Ctl_Info not implement yet");
if (FirstHalfOfMandatoryField & TracebackTable::IsFunctionNamePresentMask) {
StringRef Name = MF->getName().substr(0, INT16_MAX);
int16_t NameLength = Name.size();
CommentOS << "Function name len = "
<< static_cast<unsigned int>(NameLength);
EmitCommentAndValue(NameLength, 2);
OutStreamer->AddComment("Function Name");
OutStreamer->emitBytes(Name);
}
if (FirstHalfOfMandatoryField & TracebackTable::IsAllocaUsedMask) {
uint8_t AllocReg = XCOFF::AllocRegNo;
OutStreamer->AddComment("AllocaUsed");
OutStreamer->emitIntValueInHex(AllocReg, sizeof(AllocReg));
}
uint8_t ExtensionTableFlag = 0;
if (SecondHalfOfMandatoryField & TracebackTable::HasExtensionTableMask) {
if (ShouldEmitEHBlock)
ExtensionTableFlag |= ExtendedTBTableFlag::TB_EH_INFO;
CommentOS << "ExtensionTableFlag = "
<< getExtendedTBTableFlagString(ExtensionTableFlag);
EmitCommentAndValue(ExtensionTableFlag, sizeof(ExtensionTableFlag));
}
if (ExtensionTableFlag & ExtendedTBTableFlag::TB_EH_INFO) {
auto &Ctx = OutStreamer->getContext();
MCSymbol *EHInfoSym =
TargetLoweringObjectFileXCOFF::getEHInfoTableSymbol(MF);
MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(EHInfoSym);
const MCSymbol *TOCBaseSym =
cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
->getQualNameSymbol();
const MCExpr *Exp =
MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCEntry, Ctx),
MCSymbolRefExpr::create(TOCBaseSym, Ctx), Ctx);
const DataLayout &DL = getDataLayout();
OutStreamer->emitValueToAlignment(4);
OutStreamer->AddComment("EHInfo Table");
OutStreamer->emitValue(Exp, DL.getPointerSize());
}
#undef GENBOOLCOMMENT
#undef GENVALUECOMMENT
}
static bool isSpecialLLVMGlobalArrayToSkip(const GlobalVariable *GV) {
return GV->hasAppendingLinkage() &&
StringSwitch<bool>(GV->getName())
// TODO: Linker could still eliminate the GV if we just skip
// handling llvm.used array. Skipping them for now until we or the
// AIX OS team come up with a good solution.
.Case("llvm.used", true)
// It's correct to just skip llvm.compiler.used array here.
.Case("llvm.compiler.used", true)
.Default(false);
}
static bool isSpecialLLVMGlobalArrayForStaticInit(const GlobalVariable *GV) {
return StringSwitch<bool>(GV->getName())
.Cases("llvm.global_ctors", "llvm.global_dtors", true)
.Default(false);
}
void PPCAIXAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
// Special LLVM global arrays have been handled at the initialization.
if (isSpecialLLVMGlobalArrayToSkip(GV) || isSpecialLLVMGlobalArrayForStaticInit(GV))
return;
// If the Global Variable has the toc-data attribute, it needs to be emitted
// when we emit the .toc section.
if (GV->hasAttribute("toc-data")) {
TOCDataGlobalVars.push_back(GV);
return;
}
emitGlobalVariableHelper(GV);
}
void PPCAIXAsmPrinter::emitGlobalVariableHelper(const GlobalVariable *GV) {
assert(!GV->getName().startswith("llvm.") &&
"Unhandled intrinsic global variable.");
if (GV->hasComdat())
report_fatal_error("COMDAT not yet supported by AIX.");
MCSymbolXCOFF *GVSym = cast<MCSymbolXCOFF>(getSymbol(GV));
if (GV->isDeclarationForLinker()) {
emitLinkage(GV, GVSym);
return;
}
SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
if (!GVKind.isGlobalWriteableData() && !GVKind.isReadOnly() &&
!GVKind.isThreadLocal()) // Checks for both ThreadData and ThreadBSS.
report_fatal_error("Encountered a global variable kind that is "
"not supported yet.");
// Print GV in verbose mode
if (isVerbose()) {
if (GV->hasInitializer()) {
GV->printAsOperand(OutStreamer->GetCommentOS(),
/*PrintType=*/false, GV->getParent());
OutStreamer->GetCommentOS() << '\n';
}
}
MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
getObjFileLowering().SectionForGlobal(GV, GVKind, TM));
// Switch to the containing csect.
OutStreamer->SwitchSection(Csect);
const DataLayout &DL = GV->getParent()->getDataLayout();
// Handle common and zero-initialized local symbols.
if (GV->hasCommonLinkage() || GVKind.isBSSLocal() ||
GVKind.isThreadBSSLocal()) {
Align Alignment = GV->getAlign().getValueOr(DL.getPreferredAlign(GV));
uint64_t Size = DL.getTypeAllocSize(GV->getType()->getElementType());
GVSym->setStorageClass(
TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV));
if (GVKind.isBSSLocal() || GVKind.isThreadBSSLocal())
OutStreamer->emitXCOFFLocalCommonSymbol(
OutContext.getOrCreateSymbol(GVSym->getSymbolTableName()), Size,
GVSym, Alignment.value());
else
OutStreamer->emitCommonSymbol(GVSym, Size, Alignment.value());
return;
}
MCSymbol *EmittedInitSym = GVSym;
emitLinkage(GV, EmittedInitSym);
emitAlignment(getGVAlignment(GV, DL), GV);
// When -fdata-sections is enabled, every GlobalVariable will
// be put into its own csect; therefore, label is not necessary here.
if (!TM.getDataSections() || GV->hasSection()) {
OutStreamer->emitLabel(EmittedInitSym);
}
// Emit aliasing label for global variable.
llvm::for_each(GOAliasMap[GV], [this](const GlobalAlias *Alias) {
OutStreamer->emitLabel(getSymbol(Alias));
});
emitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
}
void PPCAIXAsmPrinter::emitFunctionDescriptor() {
const DataLayout &DL = getDataLayout();
const unsigned PointerSize = DL.getPointerSizeInBits() == 64 ? 8 : 4;
MCSectionSubPair Current = OutStreamer->getCurrentSection();
// Emit function descriptor.
OutStreamer->SwitchSection(
cast<MCSymbolXCOFF>(CurrentFnDescSym)->getRepresentedCsect());
// Emit aliasing label for function descriptor csect.
llvm::for_each(GOAliasMap[&MF->getFunction()],
[this](const GlobalAlias *Alias) {
OutStreamer->emitLabel(getSymbol(Alias));
});
// Emit function entry point address.
OutStreamer->emitValue(MCSymbolRefExpr::create(CurrentFnSym, OutContext),
PointerSize);
// Emit TOC base address.
const MCSymbol *TOCBaseSym =
cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
->getQualNameSymbol();
OutStreamer->emitValue(MCSymbolRefExpr::create(TOCBaseSym, OutContext),
PointerSize);
// Emit a null environment pointer.
OutStreamer->emitIntValue(0, PointerSize);
OutStreamer->SwitchSection(Current.first, Current.second);
}
void PPCAIXAsmPrinter::emitFunctionEntryLabel() {
// It's not necessary to emit the label when we have individual
// function in its own csect.
if (!TM.getFunctionSections())
PPCAsmPrinter::emitFunctionEntryLabel();
// Emit aliasing label for function entry point label.
llvm::for_each(
GOAliasMap[&MF->getFunction()], [this](const GlobalAlias *Alias) {
OutStreamer->emitLabel(
getObjFileLowering().getFunctionEntryPointSymbol(Alias, TM));
});
}
void PPCAIXAsmPrinter::emitEndOfAsmFile(Module &M) {
// If there are no functions and there are no toc-data definitions in this
// module, we will never need to reference the TOC base.
if (M.empty() && TOCDataGlobalVars.empty())
return;
// Switch to section to emit TOC base.
OutStreamer->SwitchSection(getObjFileLowering().getTOCBaseSection());
PPCTargetStreamer *TS =
static_cast<PPCTargetStreamer *>(OutStreamer->getTargetStreamer());
for (auto &I : TOC) {
MCSectionXCOFF *TCEntry;
// Setup the csect for the current TC entry. If the variant kind is
// VK_PPC_AIX_TLSGDM the entry represents the region handle, we create a
// new symbol to prefix the name with a dot.
if (I.first.second == MCSymbolRefExpr::VariantKind::VK_PPC_AIX_TLSGDM) {
SmallString<128> Name;
StringRef Prefix = ".";
Name += Prefix;
Name += I.first.first->getName();
MCSymbol *S = OutContext.getOrCreateSymbol(Name);
TCEntry = cast<MCSectionXCOFF>(
getObjFileLowering().getSectionForTOCEntry(S, TM));
} else {
TCEntry = cast<MCSectionXCOFF>(
getObjFileLowering().getSectionForTOCEntry(I.first.first, TM));
}
OutStreamer->SwitchSection(TCEntry);
OutStreamer->emitLabel(I.second);
if (TS != nullptr)
TS->emitTCEntry(*I.first.first, I.first.second);
}
for (const auto *GV : TOCDataGlobalVars)
emitGlobalVariableHelper(GV);
}
bool PPCAIXAsmPrinter::doInitialization(Module &M) {
const bool Result = PPCAsmPrinter::doInitialization(M);
auto setCsectAlignment = [this](const GlobalObject *GO) {
// Declarations have 0 alignment which is set by default.
if (GO->isDeclarationForLinker())
return;
SectionKind GOKind = getObjFileLowering().getKindForGlobal(GO, TM);
MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
getObjFileLowering().SectionForGlobal(GO, GOKind, TM));
Align GOAlign = getGVAlignment(GO, GO->getParent()->getDataLayout());
if (GOAlign > Csect->getAlignment())
Csect->setAlignment(GOAlign);
};
// We need to know, up front, the alignment of csects for the assembly path,
// because once a .csect directive gets emitted, we could not change the
// alignment value on it.
for (const auto &G : M.globals()) {
if (isSpecialLLVMGlobalArrayToSkip(&G))
continue;
if (isSpecialLLVMGlobalArrayForStaticInit(&G)) {
// Generate a format indicator and a unique module id to be a part of
// the sinit and sterm function names.
if (FormatIndicatorAndUniqueModId.empty()) {
std::string UniqueModuleId = getUniqueModuleId(&M);
if (UniqueModuleId != "")
// TODO: Use source file full path to generate the unique module id
// and add a format indicator as a part of function name in case we
// will support more than one format.
FormatIndicatorAndUniqueModId = "clang_" + UniqueModuleId.substr(1);
else
// Use the Pid and current time as the unique module id when we cannot
// generate one based on a module's strong external symbols.
// FIXME: Adjust the comment accordingly after we use source file full
// path instead.
FormatIndicatorAndUniqueModId =
"clangPidTime_" + llvm::itostr(sys::Process::getProcessId()) +
"_" + llvm::itostr(time(nullptr));
}
emitSpecialLLVMGlobal(&G);
continue;
}
setCsectAlignment(&G);
}
for (const auto &F : M)
setCsectAlignment(&F);
// Construct an aliasing list for each GlobalObject.
for (const auto &Alias : M.aliases()) {
const GlobalObject *Base = Alias.getBaseObject();
if (!Base)
report_fatal_error(
"alias without a base object is not yet supported on AIX");
GOAliasMap[Base].push_back(&Alias);
}
return Result;
}
void PPCAIXAsmPrinter::emitInstruction(const MachineInstr *MI) {
switch (MI->getOpcode()) {
default:
break;
case PPC::GETtlsADDR64AIX:
case PPC::GETtlsADDR32AIX: {
// The reference to .__tls_get_addr is unknown to the assembler
// so we need to emit an external symbol reference.
MCSymbol *TlsGetAddr = createMCSymbolForTlsGetAddr(OutContext);
ExtSymSDNodeSymbols.insert(TlsGetAddr);
break;
}
case PPC::BL8:
case PPC::BL:
case PPC::BL8_NOP:
case PPC::BL_NOP: {
const MachineOperand &MO = MI->getOperand(0);
if (MO.isSymbol()) {
MCSymbolXCOFF *S =
cast<MCSymbolXCOFF>(OutContext.getOrCreateSymbol(MO.getSymbolName()));
ExtSymSDNodeSymbols.insert(S);
}
} break;
case PPC::BL_TLS:
case PPC::BL8_TLS:
case PPC::BL8_TLS_:
case PPC::BL8_NOP_TLS:
report_fatal_error("TLS call not yet implemented");
case PPC::TAILB:
case PPC::TAILB8:
case PPC::TAILBA:
case PPC::TAILBA8:
case PPC::TAILBCTR:
case PPC::TAILBCTR8:
if (MI->getOperand(0).isSymbol())
report_fatal_error("Tail call for extern symbol not yet supported.");
break;
}
return PPCAsmPrinter::emitInstruction(MI);
}
bool PPCAIXAsmPrinter::doFinalization(Module &M) {
// Do streamer related finalization for DWARF.
if (!MAI->usesDwarfFileAndLocDirectives() && MMI->hasDebugInfo())
OutStreamer->doFinalizationAtSectionEnd(
OutStreamer->getContext().getObjectFileInfo()->getTextSection());
for (MCSymbol *Sym : ExtSymSDNodeSymbols)
OutStreamer->emitSymbolAttribute(Sym, MCSA_Extern);
return PPCAsmPrinter::doFinalization(M);
}
static unsigned mapToSinitPriority(int P) {
if (P < 0 || P > 65535)
report_fatal_error("invalid init priority");
if (P <= 20)
return P;
if (P < 81)
return 20 + (P - 20) * 16;
if (P <= 1124)
return 1004 + (P - 81);
if (P < 64512)
return 2047 + (P - 1124) * 33878;
return 2147482625u + (P - 64512);
}
static std::string convertToSinitPriority(int Priority) {
// This helper function converts clang init priority to values used in sinit
// and sterm functions.
//
// The conversion strategies are:
// We map the reserved clang/gnu priority range [0, 100] into the sinit/sterm
// reserved priority range [0, 1023] by
// - directly mapping the first 21 and the last 20 elements of the ranges
// - linear interpolating the intermediate values with a step size of 16.
//
// We map the non reserved clang/gnu priority range of [101, 65535] into the
// sinit/sterm priority range [1024, 2147483648] by:
// - directly mapping the first and the last 1024 elements of the ranges
// - linear interpolating the intermediate values with a step size of 33878.
unsigned int P = mapToSinitPriority(Priority);
std::string PrioritySuffix;
llvm::raw_string_ostream os(PrioritySuffix);
os << llvm::format_hex_no_prefix(P, 8);
os.flush();
return PrioritySuffix;
}
void PPCAIXAsmPrinter::emitXXStructorList(const DataLayout &DL,
const Constant *List, bool IsCtor) {
SmallVector<Structor, 8> Structors;
preprocessXXStructorList(DL, List, Structors);
if (Structors.empty())
return;
unsigned Index = 0;
for (Structor &S : Structors) {
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(S.Func))
S.Func = CE->getOperand(0);
llvm::GlobalAlias::create(
GlobalValue::ExternalLinkage,
(IsCtor ? llvm::Twine("__sinit") : llvm::Twine("__sterm")) +
llvm::Twine(convertToSinitPriority(S.Priority)) +
llvm::Twine("_", FormatIndicatorAndUniqueModId) +
llvm::Twine("_", llvm::utostr(Index++)),
cast<Function>(S.Func));
}
}
void PPCAIXAsmPrinter::emitTTypeReference(const GlobalValue *GV,
unsigned Encoding) {
if (GV) {
MCSymbol *TypeInfoSym = TM.getSymbol(GV);
MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(TypeInfoSym);
const MCSymbol *TOCBaseSym =
cast<MCSectionXCOFF>(getObjFileLowering().getTOCBaseSection())
->getQualNameSymbol();
auto &Ctx = OutStreamer->getContext();
const MCExpr *Exp =
MCBinaryExpr::createSub(MCSymbolRefExpr::create(TOCEntry, Ctx),
MCSymbolRefExpr::create(TOCBaseSym, Ctx), Ctx);
OutStreamer->emitValue(Exp, GetSizeOfEncodedValue(Encoding));
} else
OutStreamer->emitIntValue(0, GetSizeOfEncodedValue(Encoding));
}
// Return a pass that prints the PPC assembly code for a MachineFunction to the
// given output stream.
static AsmPrinter *
createPPCAsmPrinterPass(TargetMachine &tm,
std::unique_ptr<MCStreamer> &&Streamer) {
if (tm.getTargetTriple().isOSAIX())
return new PPCAIXAsmPrinter(tm, std::move(Streamer));
return new PPCLinuxAsmPrinter(tm, std::move(Streamer));
}
// Force static initialization.
extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializePowerPCAsmPrinter() {
TargetRegistry::RegisterAsmPrinter(getThePPC32Target(),
createPPCAsmPrinterPass);
TargetRegistry::RegisterAsmPrinter(getThePPC32LETarget(),
createPPCAsmPrinterPass);
TargetRegistry::RegisterAsmPrinter(getThePPC64Target(),
createPPCAsmPrinterPass);
TargetRegistry::RegisterAsmPrinter(getThePPC64LETarget(),
createPPCAsmPrinterPass);
}
|
[
"[email protected]"
] | |
0dc3941f7cc97ce6c26c1657cde3c6adabfff8ab
|
2bb497da37a35c942bb4cf13cbf9efecff57a833
|
/Source/TestinGrounds/TestinGrounds.cpp
|
06b382badd8e0802492a1851e6c261d66f5268d1
|
[] |
no_license
|
Mikleodeon/TestinGrounds
|
83c7b43921996fdb25d559b03e0bc92afc11b8a4
|
368b7a4b3bae3b62365320354d58e63ce35318cf
|
refs/heads/master
| 2020-03-09T14:13:48.864400 | 2018-04-18T16:00:40 | 2018-04-18T17:14:24 | 128,829,478 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 215 |
cpp
|
// Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.
#include "TestinGrounds.h"
#include "Modules/ModuleManager.h"
IMPLEMENT_PRIMARY_GAME_MODULE( FDefaultGameModuleImpl, TestinGrounds, "TestinGrounds" );
|
[
"[email protected]"
] | |
dc4b4bb741e3b66d725abba7aab95c444d4ae44c
|
1942a0d16bd48962e72aa21fad8d034fa9521a6c
|
/aws-cpp-sdk-storagegateway/include/aws/storagegateway/model/CreateCachediSCSIVolumeRequest.h
|
2c200e5899a740fbc8c1e05151bbe1433d7da13f
|
[
"Apache-2.0",
"JSON",
"MIT"
] |
permissive
|
yecol/aws-sdk-cpp
|
1aff09a21cfe618e272c2c06d358cfa0fb07cecf
|
0b1ea31e593d23b5db49ee39d0a11e5b98ab991e
|
refs/heads/master
| 2021-01-20T02:53:53.557861 | 2018-02-11T11:14:58 | 2018-02-11T11:14:58 | 83,822,910 | 0 | 1 | null | 2017-03-03T17:17:00 | 2017-03-03T17:17:00 | null |
UTF-8
|
C++
| false | false | 9,430 |
h
|
/*
* Copyright 2010-2016 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/storagegateway/StorageGateway_EXPORTS.h>
#include <aws/storagegateway/StorageGatewayRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
namespace Aws
{
namespace StorageGateway
{
namespace Model
{
/**
*/
class AWS_STORAGEGATEWAY_API CreateCachediSCSIVolumeRequest : public StorageGatewayRequest
{
public:
CreateCachediSCSIVolumeRequest();
Aws::String SerializePayload() const override;
Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
inline const Aws::String& GetGatewayARN() const{ return m_gatewayARN; }
inline void SetGatewayARN(const Aws::String& value) { m_gatewayARNHasBeenSet = true; m_gatewayARN = value; }
inline void SetGatewayARN(Aws::String&& value) { m_gatewayARNHasBeenSet = true; m_gatewayARN = value; }
inline void SetGatewayARN(const char* value) { m_gatewayARNHasBeenSet = true; m_gatewayARN.assign(value); }
inline CreateCachediSCSIVolumeRequest& WithGatewayARN(const Aws::String& value) { SetGatewayARN(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithGatewayARN(Aws::String&& value) { SetGatewayARN(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithGatewayARN(const char* value) { SetGatewayARN(value); return *this;}
inline long long GetVolumeSizeInBytes() const{ return m_volumeSizeInBytes; }
inline void SetVolumeSizeInBytes(long long value) { m_volumeSizeInBytesHasBeenSet = true; m_volumeSizeInBytes = value; }
inline CreateCachediSCSIVolumeRequest& WithVolumeSizeInBytes(long long value) { SetVolumeSizeInBytes(value); return *this;}
inline const Aws::String& GetSnapshotId() const{ return m_snapshotId; }
inline void SetSnapshotId(const Aws::String& value) { m_snapshotIdHasBeenSet = true; m_snapshotId = value; }
inline void SetSnapshotId(Aws::String&& value) { m_snapshotIdHasBeenSet = true; m_snapshotId = value; }
inline void SetSnapshotId(const char* value) { m_snapshotIdHasBeenSet = true; m_snapshotId.assign(value); }
inline CreateCachediSCSIVolumeRequest& WithSnapshotId(const Aws::String& value) { SetSnapshotId(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithSnapshotId(Aws::String&& value) { SetSnapshotId(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithSnapshotId(const char* value) { SetSnapshotId(value); return *this;}
inline const Aws::String& GetTargetName() const{ return m_targetName; }
inline void SetTargetName(const Aws::String& value) { m_targetNameHasBeenSet = true; m_targetName = value; }
inline void SetTargetName(Aws::String&& value) { m_targetNameHasBeenSet = true; m_targetName = value; }
inline void SetTargetName(const char* value) { m_targetNameHasBeenSet = true; m_targetName.assign(value); }
inline CreateCachediSCSIVolumeRequest& WithTargetName(const Aws::String& value) { SetTargetName(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithTargetName(Aws::String&& value) { SetTargetName(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithTargetName(const char* value) { SetTargetName(value); return *this;}
/**
* <p>The ARN for an existing volume. Specifying this ARN makes the new volume into
* an exact copy of the specified existing volume's latest recovery point. The
* <code>VolumeSizeInBytes</code> value for this new volume must be equal to or
* larger than the size of the existing volume, in bytes.</p>
*/
inline const Aws::String& GetSourceVolumeARN() const{ return m_sourceVolumeARN; }
/**
* <p>The ARN for an existing volume. Specifying this ARN makes the new volume into
* an exact copy of the specified existing volume's latest recovery point. The
* <code>VolumeSizeInBytes</code> value for this new volume must be equal to or
* larger than the size of the existing volume, in bytes.</p>
*/
inline void SetSourceVolumeARN(const Aws::String& value) { m_sourceVolumeARNHasBeenSet = true; m_sourceVolumeARN = value; }
/**
* <p>The ARN for an existing volume. Specifying this ARN makes the new volume into
* an exact copy of the specified existing volume's latest recovery point. The
* <code>VolumeSizeInBytes</code> value for this new volume must be equal to or
* larger than the size of the existing volume, in bytes.</p>
*/
inline void SetSourceVolumeARN(Aws::String&& value) { m_sourceVolumeARNHasBeenSet = true; m_sourceVolumeARN = value; }
/**
* <p>The ARN for an existing volume. Specifying this ARN makes the new volume into
* an exact copy of the specified existing volume's latest recovery point. The
* <code>VolumeSizeInBytes</code> value for this new volume must be equal to or
* larger than the size of the existing volume, in bytes.</p>
*/
inline void SetSourceVolumeARN(const char* value) { m_sourceVolumeARNHasBeenSet = true; m_sourceVolumeARN.assign(value); }
/**
* <p>The ARN for an existing volume. Specifying this ARN makes the new volume into
* an exact copy of the specified existing volume's latest recovery point. The
* <code>VolumeSizeInBytes</code> value for this new volume must be equal to or
* larger than the size of the existing volume, in bytes.</p>
*/
inline CreateCachediSCSIVolumeRequest& WithSourceVolumeARN(const Aws::String& value) { SetSourceVolumeARN(value); return *this;}
/**
* <p>The ARN for an existing volume. Specifying this ARN makes the new volume into
* an exact copy of the specified existing volume's latest recovery point. The
* <code>VolumeSizeInBytes</code> value for this new volume must be equal to or
* larger than the size of the existing volume, in bytes.</p>
*/
inline CreateCachediSCSIVolumeRequest& WithSourceVolumeARN(Aws::String&& value) { SetSourceVolumeARN(value); return *this;}
/**
* <p>The ARN for an existing volume. Specifying this ARN makes the new volume into
* an exact copy of the specified existing volume's latest recovery point. The
* <code>VolumeSizeInBytes</code> value for this new volume must be equal to or
* larger than the size of the existing volume, in bytes.</p>
*/
inline CreateCachediSCSIVolumeRequest& WithSourceVolumeARN(const char* value) { SetSourceVolumeARN(value); return *this;}
inline const Aws::String& GetNetworkInterfaceId() const{ return m_networkInterfaceId; }
inline void SetNetworkInterfaceId(const Aws::String& value) { m_networkInterfaceIdHasBeenSet = true; m_networkInterfaceId = value; }
inline void SetNetworkInterfaceId(Aws::String&& value) { m_networkInterfaceIdHasBeenSet = true; m_networkInterfaceId = value; }
inline void SetNetworkInterfaceId(const char* value) { m_networkInterfaceIdHasBeenSet = true; m_networkInterfaceId.assign(value); }
inline CreateCachediSCSIVolumeRequest& WithNetworkInterfaceId(const Aws::String& value) { SetNetworkInterfaceId(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithNetworkInterfaceId(Aws::String&& value) { SetNetworkInterfaceId(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithNetworkInterfaceId(const char* value) { SetNetworkInterfaceId(value); return *this;}
inline const Aws::String& GetClientToken() const{ return m_clientToken; }
inline void SetClientToken(const Aws::String& value) { m_clientTokenHasBeenSet = true; m_clientToken = value; }
inline void SetClientToken(Aws::String&& value) { m_clientTokenHasBeenSet = true; m_clientToken = value; }
inline void SetClientToken(const char* value) { m_clientTokenHasBeenSet = true; m_clientToken.assign(value); }
inline CreateCachediSCSIVolumeRequest& WithClientToken(const Aws::String& value) { SetClientToken(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithClientToken(Aws::String&& value) { SetClientToken(value); return *this;}
inline CreateCachediSCSIVolumeRequest& WithClientToken(const char* value) { SetClientToken(value); return *this;}
private:
Aws::String m_gatewayARN;
bool m_gatewayARNHasBeenSet;
long long m_volumeSizeInBytes;
bool m_volumeSizeInBytesHasBeenSet;
Aws::String m_snapshotId;
bool m_snapshotIdHasBeenSet;
Aws::String m_targetName;
bool m_targetNameHasBeenSet;
Aws::String m_sourceVolumeARN;
bool m_sourceVolumeARNHasBeenSet;
Aws::String m_networkInterfaceId;
bool m_networkInterfaceIdHasBeenSet;
Aws::String m_clientToken;
bool m_clientTokenHasBeenSet;
};
} // namespace Model
} // namespace StorageGateway
} // namespace Aws
|
[
"[email protected]"
] | |
633f9fe37f892b448630a637e89618ca0a267730
|
4e035c6d51fa19cbdf4f584867b55e7813b69869
|
/include/Misc/ZHM5SBTagMode.h
|
0032dbcacf435d05cf74d066d1002b6800c0ecd5
|
[] |
no_license
|
ipoopedmypantsuups/HitmanAbsolutionSDK
|
d28ec117f8da8c2f1bab3068a17c7143c5f83ea4
|
c4a211550dc66687df9bdae5d4c0bf665d48f5ad
|
refs/heads/main
| 2023-03-08T05:04:24.939062 | 2021-02-20T08:07:30 | 2021-02-20T08:07:30 | 359,103,783 | 0 | 0 | null | 2021-04-18T09:50:59 | 2021-04-18T09:50:58 | null |
UTF-8
|
C++
| false | false | 1,071 |
h
|
#pragma once
#include "ZHM5SBTag.h"
#include "SHM5SBShared.h"
#include "ESBTagMode.h"
#include "SCharacterTagInfo.h"
class alignas(16) ZHM5SBTagMode
{
public:
ZHM5SBTag m_aTags[32];
unsigned int m_nNumTags;
unsigned int m_nMaxNumTags;
TArray<ZHM5SBTag> m_aUntaggableActorTags;
bool m_bZoom;
bool m_bTriggerAimAssist;
bool m_bLastTag;
bool m_bPropCostOverride;
float m_fPropCost;
float m_fFocalDist;
float m_fWeaponMinFractionBetweenTags;
float m_fAutoModeFireRate;
float m_fTagTimeAutoMode;
unsigned int m_nNumAutoShotsMade;
const SHM5SBShared* m_SBShared;
bool m_bCanTag;
TEntityRef<IHM5ItemWeapon> m_arWeapons[2];
unsigned int m_anStartAmmo[2];
ESBTagMode m_eTagMode;
TFixedArray<SCharacterTagInfo, 32> m_aHitCharacters;
unsigned int m_nHitCharacters;
SAimCandidate m_LastCandidate;
TArray<float4> m_ArcPositions;
bool m_bLookAtPosInitialized;
float4 m_vLookAtPos;
float4 m_vLookAtDir;
bool m_bAllowPlayerToExecute;
bool m_bExecuteWhenInstinctRunsOut;
};
|
[
"[email protected]"
] | |
8575b1f2052cba3d7ff9a5a2ff84b240f716d011
|
b0a44e67a341e7ba68cb2de1fc92930bb975aa9a
|
/canfinishcourse.cpp
|
061359ef88ac3ce553b50b9776f3081a0c9d36e0
|
[] |
no_license
|
aparnag7/LeetCode-problems
|
62d3f069a7408d094bbf38fac172a6cd664f9f6f
|
fc86fb32dbdc8c7c6624323f143a229ea28c9d9b
|
refs/heads/master
| 2022-12-20T10:04:56.843151 | 2020-08-30T17:14:52 | 2020-08-30T17:14:52 | 291,316,645 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,057 |
cpp
|
class Solution {
public:
bool iscyclic(vector<vector<int>> &adj,int curr,vector<int> &visited){
if(visited[curr]==2)
return true;
visited[curr]=2;
for(int i=0;i<adj[curr].size();i++) {
if(visited[adj[curr][i]]!=1){
if(iscyclic(adj ,adj[curr][i],visited))
return true;
}
}
visited[curr]=1;
return false;
}
bool canFinish(int numCourses, vector<vector<int>>& prerequisites) {
vector<vector<int>> adj(numCourses);
vector<int> visited(numCourses , 0);
for(int i=0;i<prerequisites.size();i++)
adj[prerequisites[i][0]].push_back(prerequisites[i][1]);
for(int i=0;i< numCourses;i++){
if(visited[i]==0) {
if(iscyclic(adj,i,visited)) //If cource a is prerequisite for course b and course b is a prerequisite for course a then we cannot take either of courses
return false;
}
}
return true;
}
};
|
[
"[email protected]"
] | |
f1bb652b5128710b9f4603f3b6565f3d95e6e6b1
|
2a9fa870f43a41c131662ede8ce44464ddff8e71
|
/build-communicationSerieExoDiapo-Desktop_Qt_5_11_1_GCC_64bit-Debug/ui_widget.h
|
4573aa8dc2b92ce2d91c85d8570486cfb8577354
|
[] |
no_license
|
LehouxKevin/QtCreator
|
9fc9a05ddc3add2ec7ce2606ea715345e3721c1d
|
3d50ead86ac4754b7f6695b35752787aa9d50873
|
refs/heads/master
| 2022-01-19T23:19:25.969107 | 2019-06-28T14:36:03 | 2019-06-28T14:36:03 | 194,287,905 | 1 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 4,474 |
h
|
/********************************************************************************
** Form generated from reading UI file 'widget.ui'
**
** Created by: Qt User Interface Compiler version 5.11.1
**
** WARNING! All changes made in this file will be lost when recompiling UI file!
********************************************************************************/
#ifndef UI_WIDGET_H
#define UI_WIDGET_H
#include <QtCore/QVariant>
#include <QtWidgets/QApplication>
#include <QtWidgets/QComboBox>
#include <QtWidgets/QHBoxLayout>
#include <QtWidgets/QLabel>
#include <QtWidgets/QLineEdit>
#include <QtWidgets/QPushButton>
#include <QtWidgets/QTextBrowser>
#include <QtWidgets/QWidget>
QT_BEGIN_NAMESPACE
class Ui_Widget
{
public:
QComboBox *comboBoxListePort;
QPushButton *pushButtonOuvrirPort;
QLabel *labelEtat;
QLabel *labelTexteRecu;
QTextBrowser *textBrowserTexteRecu;
QPushButton *pushButtonQuitter;
QWidget *widget;
QHBoxLayout *horizontalLayout;
QLabel *labelTexteAenvoyer;
QLineEdit *lineEditTexteAenvoyer;
QPushButton *pushButtonEnvoyer;
void setupUi(QWidget *Widget)
{
if (Widget->objectName().isEmpty())
Widget->setObjectName(QStringLiteral("Widget"));
Widget->resize(603, 541);
comboBoxListePort = new QComboBox(Widget);
comboBoxListePort->setObjectName(QStringLiteral("comboBoxListePort"));
comboBoxListePort->setGeometry(QRect(10, 20, 201, 25));
pushButtonOuvrirPort = new QPushButton(Widget);
pushButtonOuvrirPort->setObjectName(QStringLiteral("pushButtonOuvrirPort"));
pushButtonOuvrirPort->setGeometry(QRect(230, 20, 191, 25));
labelEtat = new QLabel(Widget);
labelEtat->setObjectName(QStringLiteral("labelEtat"));
labelEtat->setGeometry(QRect(440, 20, 54, 17));
labelTexteRecu = new QLabel(Widget);
labelTexteRecu->setObjectName(QStringLiteral("labelTexteRecu"));
labelTexteRecu->setGeometry(QRect(10, 100, 81, 17));
textBrowserTexteRecu = new QTextBrowser(Widget);
textBrowserTexteRecu->setObjectName(QStringLiteral("textBrowserTexteRecu"));
textBrowserTexteRecu->setGeometry(QRect(10, 130, 571, 371));
pushButtonQuitter = new QPushButton(Widget);
pushButtonQuitter->setObjectName(QStringLiteral("pushButtonQuitter"));
pushButtonQuitter->setGeometry(QRect(10, 510, 571, 25));
widget = new QWidget(Widget);
widget->setObjectName(QStringLiteral("widget"));
widget->setGeometry(QRect(10, 60, 561, 27));
horizontalLayout = new QHBoxLayout(widget);
horizontalLayout->setSpacing(6);
horizontalLayout->setContentsMargins(11, 11, 11, 11);
horizontalLayout->setObjectName(QStringLiteral("horizontalLayout"));
horizontalLayout->setContentsMargins(0, 0, 0, 0);
labelTexteAenvoyer = new QLabel(widget);
labelTexteAenvoyer->setObjectName(QStringLiteral("labelTexteAenvoyer"));
horizontalLayout->addWidget(labelTexteAenvoyer);
lineEditTexteAenvoyer = new QLineEdit(widget);
lineEditTexteAenvoyer->setObjectName(QStringLiteral("lineEditTexteAenvoyer"));
horizontalLayout->addWidget(lineEditTexteAenvoyer);
pushButtonEnvoyer = new QPushButton(widget);
pushButtonEnvoyer->setObjectName(QStringLiteral("pushButtonEnvoyer"));
horizontalLayout->addWidget(pushButtonEnvoyer);
retranslateUi(Widget);
QObject::connect(pushButtonQuitter, SIGNAL(clicked()), Widget, SLOT(close()));
QMetaObject::connectSlotsByName(Widget);
} // setupUi
void retranslateUi(QWidget *Widget)
{
Widget->setWindowTitle(QApplication::translate("Widget", "Widget", nullptr));
pushButtonOuvrirPort->setText(QApplication::translate("Widget", "Ouvrir le port s\303\251rie", nullptr));
labelEtat->setText(QApplication::translate("Widget", "etat", nullptr));
labelTexteRecu->setText(QApplication::translate("Widget", "Texte re\303\247u", nullptr));
pushButtonQuitter->setText(QApplication::translate("Widget", "Quitter", nullptr));
labelTexteAenvoyer->setText(QApplication::translate("Widget", "Texte a envoyer", nullptr));
pushButtonEnvoyer->setText(QApplication::translate("Widget", "Envoyer", nullptr));
} // retranslateUi
};
namespace Ui {
class Widget: public Ui_Widget {};
} // namespace Ui
QT_END_NAMESPACE
#endif // UI_WIDGET_H
|
[
"[email protected]"
] | |
ace9ae2dafee0300405622d02d1eb3c0725297a2
|
16d9598f5bd6d82a5599c6c2232f2dfc75b58cb4
|
/Firebase-ESP-Client-main/examples/Cloud_Functions/List_Functions/List_Functions.ino
|
a1f70d363280b17b764e3a44160e80717075b204
|
[
"LicenseRef-scancode-other-permissive",
"MIT"
] |
permissive
|
bbbbth14/DATN_OfficalMasterSlave
|
49e6b21a6f91e9e507fed04088d0313236bf5d5b
|
87d037e582c5e53f0ef6e29c1636c43c6f294ad2
|
refs/heads/master
| 2023-04-24T23:58:49.645517 | 2021-05-19T19:03:29 | 2021-05-19T19:03:29 | 368,974,231 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 4,091 |
ino
|
/**
* Created by K. Suwatchai (Mobizt)
*
* Email: [email protected]
*
* Github: https://github.com/mobizt
*
* Copyright (c) 2021 mobizt
*
*/
/** Prerequisites
*
* Cloud Functions deployment requires the pay-as-you-go (Blaze) billing plan.
*
* IAM owner permission required for service account used and Cloud Build API must be enabled,
* https://github.com/mobizt/Firebase-ESP-Client#iam-permission-and-api-enable
*/
/* Cloud Functions deployment requires the pay-as-you-go (Blaze) billing plan. */
/** This example shows how to list the Cloud Functions.
*
* This operation required OAUth2.0 authentication.
*/
/** Due to the processing power in ESP8266 is weaker than ESP32, the OAuth2.0 token generation takes time then this example
* will check for token to be ready in loop prior to list the Cloud Functions.
*/
#if defined(ESP32)
#include <WiFi.h>
#elif defined(ESP8266)
#include <ESP8266WiFi.h>
#endif
#include <Firebase_ESP_Client.h>
//Provide the token generation process info.
#include "addons/TokenHelper.h"
/* 1. Define the WiFi credentials */
#define WIFI_SSID "WIFI_AP"
#define WIFI_PASSWORD "WIFI_PASSWORD"
/** 2. Define the Service Account credentials (required for token generation)
*
* This information can be taken from the service account JSON file.
*
* To download service account file, from the Firebase console, goto project settings,
* select "Service accounts" tab and click at "Generate new private key" button
*/
#define FIREBASE_PROJECT_ID "PROJECT_ID"
#define FIREBASE_CLIENT_EMAIL "CLIENT_EMAIL"
const char PRIVATE_KEY[] PROGMEM = "-----BEGIN PRIVATE KEY-----XXXXXXXXXXXX-----END PRIVATE KEY-----\n";
/* 3. Define the project location e.g. us-central1 or asia-northeast1 */
//https://firebase.google.com/docs/projects/locations
#define PROJECT_LOCATION "PROJECT_LOCATION"
/* 4. If work with RTDB, define the RTDB URL */
#define DATABASE_URL "URL" //<databaseName>.firebaseio.com or <databaseName>.<region>.firebasedatabase.app
//Define Firebase Data object
FirebaseData fbdo;
FirebaseAuth auth;
FirebaseConfig config;
bool taskCompleted = false;
unsigned long dataMillis = 0;
/* The function to list the Cloud Functions */
void listFunctions();
void setup()
{
Serial.begin(115200);
WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
Serial.print("Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED)
{
Serial.print(".");
delay(300);
}
Serial.println();
Serial.print("Connected with IP: ");
Serial.println(WiFi.localIP());
Serial.println();
/* Assign the Service Account credentials */
config.service_account.data.client_email = FIREBASE_CLIENT_EMAIL;
config.service_account.data.project_id = FIREBASE_PROJECT_ID;
config.service_account.data.private_key = PRIVATE_KEY;
/* Assign the RTDB URL */
config.database_url = DATABASE_URL;
/* Assign the callback function for the long running token generation task */
config.token_status_callback = tokenStatusCallback; //see addons/TokenHelper.h
Firebase.begin(&config, &auth);
Firebase.reconnectWiFi(true);
#if defined(ESP8266)
//Set the size of WiFi rx/tx buffers in the case where we want to work with large data.
fbdo.setBSSLBufferSize(1024, 1024);
#endif
}
void loop()
{
if (Firebase.ready() && !taskCompleted)
{
listFunctions();
taskCompleted = true;
}
}
void listFunctions()
{
Serial.println("------------------------------------");
Serial.println("List the Googgle Cloud Functions...");
if (Firebase.Functions.listFunctions(&fbdo, FIREBASE_PROJECT_ID /* project id */, PROJECT_LOCATION /* project location */, 1 /* page size */))
{
Serial.println("PASSED");
Serial.println(fbdo.payload());
Serial.println("------------------------------------");
Serial.println();
}
else
{
Serial.println("FAILED");
Serial.println("REASON: " + fbdo.errorReason());
Serial.println("------------------------------------");
Serial.println();
}
}
|
[
"[email protected]"
] | |
2fe8461616ba81d2effbd584f0db6c52c13c5e01
|
841fab87b64530e17e43495d6b3a3c8fdcd1ea61
|
/code/WPILib/CInterfaces/CPWM.cpp
|
50e7e764155ce61338dfac71fa64af4e27b4a586
|
[
"MIT"
] |
permissive
|
trc492/Frc2012ReboundRumble
|
86c8058a04cee0b63a67de28688df7137e49ee75
|
b1e60e8bcd43a0a86d0dfefe094a017f9ecf34c8
|
refs/heads/master
| 2021-01-25T04:36:35.642962 | 2018-05-27T19:34:53 | 2018-05-27T19:34:53 | 93,456,764 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,882 |
cpp
|
/*----------------------------------------------------------------------------*/
/* Copyright (c) FIRST 2008. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in $(WIND_BASE)/WPILib. */
/*----------------------------------------------------------------------------*/
#include "CInterfaces/CPWM.h"
#include "PWM.h"
#include "CInterfaces/CWrappers.h"
#include "DigitalModule.h"
static bool PWMsInitialized = false;
static PWM *PWMs[SensorBase::kDigitalModules][SensorBase::kPwmChannels];
/**
* Alloate a PWM based object
*
* Allocate an instance of a PWM based object. This code is shared between the subclasses
* of PWM and is not usually created as a standalone object.
*
* @param module The slot the digital module is plugged into that corresponds to this serial port
* @param channel The PWM channel for this PWM object
* @param createObject The function callback in the subclass object that actually creates an instance
* of the appropriate class.
*/
PWM *AllocatePWM(UINT8 moduleNumber, UINT32 channel, SensorCreator createObject)
{
if (!PWMsInitialized)
{
for (unsigned i = 0; i < SensorBase::kDigitalModules; i++)
for (unsigned j = 0; j < SensorBase::kPwmChannels; j++)
PWMs[i][j] = NULL;
PWMsInitialized = true;
}
if (!SensorBase::CheckPWMModule(moduleNumber) || !SensorBase::CheckPWMChannel(channel))
return NULL;
PWM *pwm = PWMs[moduleNumber - 1][channel - 1];
if (pwm == NULL)
{
pwm = (PWM *) createObject(moduleNumber, channel);
PWMs[moduleNumber - 1][channel - 1] = pwm;
}
return pwm;
}
/**
* Alloate a PWM based object
*
* Allocate an instance of a PWM based object. This code is shared between the subclasses
* of PWM and is not usually created as a standalone object.
*
* @param channel The PWM channel for this PWM object
* @param createObject The function callback in the subclass object that actually creates an instance
* of the appropriate class.
*/
PWM *AllocatePWM(UINT32 channel, SensorCreator createObject)
{
return AllocatePWM(SensorBase::GetDefaultDigitalModule(), channel, createObject);
}
/**
* Delete a PWM
* Delete a PWM and free up all the associated resources for this object.
*
* @param slot The slot the digital module is plugged into that corresponds to this serial port
* @param channel The PWM channel for this PWM object
*/
void DeletePWM(UINT8 moduleNumber, UINT32 channel)
{
if (SensorBase::CheckPWMModule(moduleNumber) && SensorBase::CheckPWMChannel(channel))
{
PWMs[moduleNumber - 1][channel - 1] = NULL;
}
}
/**
* Delete a PWM
* Delete a PWM and free up all the associated resources for this object.
*
* @param channel The PWM channel for this PWM object
*/
void DeletePWM(UINT32 channel)
{
DeletePWM(SensorBase::GetDefaultDigitalModule(), channel);
}
|
[
"[email protected]"
] | |
a1e7f5be423f5c434c32ce485d3bcb03c92ffef2
|
8f9a92d4d26a09b85bf4a10c62511b2020129c02
|
/src/driver.h
|
f6b3a902e15a7883381e744ad35924d0ffc4fca7
|
[] |
no_license
|
junhaideng/Autoruns
|
e81359544329abb43e7bf96b92629b681c36c7f7
|
b2a898ac58fd9f9ff7b06e57bc3a28680aafd613
|
refs/heads/main
| 2023-06-13T21:37:50.129246 | 2021-06-24T07:55:41 | 2021-06-24T07:55:41 | 371,546,950 | 1 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 341 |
h
|
#ifndef DRIVER_H
#define DRIVER_H
#include <QTableWidget>
#include <vector>
#include <windows.h>
#include "utils.h"
class Driver
{
private:
int get_data(HKEY hkey, LPCWSTR lpszSubKey, vector<item> &table_data, const QString &keyname);
public:
Driver();
int setTableData(QTableWidget *table);
};
#endif // DRIVER_H
|
[
"[email protected]"
] | |
5caa8f86322629ecffe18b9a4c025710a03b54fb
|
39fb6269b96310549b766afa8557d70d605c90ad
|
/cpp/ch8/choices.cpp
|
e3af762ca5280183b013dd6d2f6d3b5b52f3298d
|
[] |
no_license
|
bazindes/zedc
|
d171aab72ec46f5e82916cda194bfb9e760e53f6
|
93f9c56fd3696a050120fa669861be93220f19f1
|
refs/heads/master
| 2020-04-29T10:24:17.426936 | 2019-04-15T05:05:59 | 2019-04-15T05:05:59 | 176,061,028 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,576 |
cpp
|
/*
choices.cpp
Created by: baz
Date: 2019-04-02 23:44
*/
#include <iostream>
template <class T> T lesser(T a, T b) { return a < b ? a : b; }
int lesser(int a, int b) {
a = a < 0 ? -a : a;
b = b < 0 ? -b : b;
return a < b ? a : b;
}
int main() {
using namespace std;
int m = 20;
int n = -30;
double x = 15.5;
double y = 25.9;
cout << lesser(m, n) << endl;
cout << lesser(x, y) << endl;
cout << lesser<>(m, n) << endl;
cout << lesser<int>(x, y) << endl;
/**
* decltype
*/
int i;
decltype(i) j; // make y the same type as x
decltype(i + j) ipj = i + j; // make xpy the same type as x+y
cout << "j is " << typeid(j).name() << endl;
cout << "ipj is " << typeid(ipj).name() << endl;
double a1 = 5.5;
double a2 = 7.9;
double &a3 = a1;
const double *pd;
decltype(a1) w; // type double
decltype(a3) u = a2; // type double &
decltype(pd) v; // type const double *
cout << "w is " << typeid(w).name() << endl;
cout << "u is " << typeid(u).name() << endl;
cout << "v is " << typeid(v).name() << endl;
long indeed(int);
decltype(indeed(3)) p; // m is type long
cout << "p is " << typeid(p).name() << endl;
double xx = 4.4;
decltype((xx)) r2 = xx; // r2 is double &
decltype(xx) r3 = xx; // r3 is double
cout << "r2 is " << typeid(r2).name() << endl;
cout << "r3 is " << typeid(r3).name() << endl;
return 0;
}
double h(int x, float y);
auto h(int x, float y) -> double; // c++11
template <class T1, class T2> auto h(T1 x, T2 y) -> decltype(x + y) {
return x + y;
}
|
[
"[email protected]"
] | |
75aaa9f9b55df239d66e7a786b2dd269630bf492
|
d848d5269d7d727718b260fd3520be5ff41d98de
|
/OGL_4/ZGL/zglProgram.cpp
|
c3d7a0a2eb0369f5005e360e02b61db00218a01b
|
[] |
no_license
|
Zandriy/OGL_4
|
e83bd29a09072460ba88d4e49c2b3b581c56624e
|
35fb6c908b584c7e5a81ee7fd2f9d635dd7e21b9
|
refs/heads/master
| 2016-09-06T21:33:03.909794 | 2014-05-18T16:08:17 | 2014-05-18T16:08:17 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 4,178 |
cpp
|
/*
* zglProgram.cpp
*
* Created on: Apr 30, 2014
* Author: Andrew Zhabura
*/
#include "zglProgram.h"
#include <fstream>
namespace ZGL
{
zglProgram::zglProgram()
: m_prgID(0)
{
}
zglProgram::~zglProgram()
{
}
bool zglProgram::LoadShaders(ShaderInfo* shaders)
{
m_prgID = glCreateProgram();
glAttachShader( m_prgID, LoadShader("",1) );
return true;
}
GLuint zglProgram::LoadShader(const char* fName, GLenum type)
{
GLchar* l_source = nullptr;
GLuint l_shader = 0;
std::ifstream l_file(fName, std::ifstream::binary);
if (l_file.is_open())
{
std::streampos l_size = l_file.tellg();
char* l_source = new char[l_size];
l_file.seekg(0, std::ios::beg);
l_file.read(l_source, l_size);
l_file.close();
}
if (!l_source)
return l_shader;
l_shader = glCreateShader( type );
glShaderSource( l_shader, 1, &l_source, NULL );
delete[] l_source;
glCompileShader( l_shader );
GLint compiled;
glGetShaderiv( l_shader, GL_COMPILE_STATUS, &compiled );
if ( !compiled ) {
#ifdef _DEBUG
GLsizei len;
glGetShaderiv( l_shader, GL_INFO_LOG_LENGTH, &len );
GLchar* log = new GLchar[len+1];
glGetShaderInfoLog( l_shader, len, &len, log );
// std::cerr << "Shader compilation failed: " << log << std::endl;
delete [] log;
#endif /* DEBUG */
return 0;
}
return l_shader;
}
bool zglProgram::ActivateProgram()
{
if (!m_prgID)
return false;
glUseProgram(m_prgID);
return true;
}
static const GLchar*
ReadShader( const char* filename )
{
#ifdef WIN32
FILE* infile;
fopen_s( &infile, filename, "rb" );
#else
FILE* infile = fopen( filename, "rb" );
#endif // WIN32
if ( !infile ) {
#ifdef _DEBUG
// std::cerr << "Unable to open file '" << filename << "'" << std::endl;
#endif /* DEBUG */
return NULL;
}
fseek( infile, 0, SEEK_END );
int len = ftell( infile );
fseek( infile, 0, SEEK_SET );
GLchar* source = new GLchar[len+1];
fread( source, 1, len, infile );
fclose( infile );
source[len] = 0;
return const_cast<const GLchar*>(source);
}
//----------------------------------------------------------------------------
GLuint
LoadShaders( ShaderInfo* shaders )
{
if ( shaders == NULL ) { return 0; }
GLuint program = glCreateProgram();
ShaderInfo* entry = shaders;
while ( entry->type != GL_NONE ) {
GLuint shader = glCreateShader( entry->type );
entry->shader = shader;
const GLchar* source = ReadShader( entry->filename );
if ( source == NULL ) {
for ( entry = shaders; entry->type != GL_NONE; ++entry ) {
glDeleteShader( entry->shader );
entry->shader = 0;
}
return 0;
}
glShaderSource( shader, 1, &source, NULL );
delete [] source;
glCompileShader( shader );
GLint compiled;
glGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
if ( !compiled ) {
#ifdef _DEBUG
GLsizei len;
glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &len );
GLchar* log = new GLchar[len+1];
glGetShaderInfoLog( shader, len, &len, log );
// std::cerr << "Shader compilation failed: " << log << std::endl;
delete [] log;
#endif /* DEBUG */
return 0;
}
glAttachShader( program, shader );
++entry;
}
#ifdef GL_VERSION_4_1
// if ( GLEW_VERSION_4_1 ) {
// // glProgramParameteri( program, GL_PROGRAM_SEPARABLE, GL_TRUE );
// }
#endif /* GL_VERSION_4_1 */
glLinkProgram( program );
GLint linked;
glGetProgramiv( program, GL_LINK_STATUS, &linked );
if ( !linked ) {
#ifdef _DEBUG
GLsizei len;
glGetProgramiv( program, GL_INFO_LOG_LENGTH, &len );
GLchar* log = new GLchar[len+1];
glGetProgramInfoLog( program, len, &len, log );
// std::cerr << "Shader linking failed: " << log << std::endl;
delete [] log;
#endif /* DEBUG */
for ( entry = shaders; entry->type != GL_NONE; ++entry ) {
glDeleteShader( entry->shader );
entry->shader = 0;
}
return 0;
}
return program;
}
} // namespace ZGL
|
[
"[email protected]"
] | |
44921bd1a010f4ff0dfb2dc2a98449364ca4554d
|
3f0881e5e30e5412460e131a16a7ddb7943162ee
|
/day05/ex05/Intern.cpp
|
f16051b90ad88d411f9988f2b9cffb2d0d61caba
|
[] |
no_license
|
RockyAZ/CPP_PISCINE
|
ce2631e0858ba25f80417758299e6bdaf102bb4d
|
c6f266c9540f9a96ab1391ea09084d1f61b14159
|
refs/heads/master
| 2020-04-01T17:53:43.303138 | 2018-10-17T13:05:57 | 2018-10-17T13:05:57 | 153,457,310 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,071 |
cpp
|
// ************************************************************************** //
// //
// ::: :::::::: //
// Intern.cpp :+: :+: :+: //
// +:+ +:+ +:+ //
// By: azaporoz <[email protected]> +#+ +:+ +#+ //
// +#+#+#+#+#+ +#+ //
// Created: 2018/10/09 19:07:51 by azaporoz #+# #+# //
// Updated: 2018/10/09 19:07:51 by azaporoz ### ########.fr //
// //
// ************************************************************************** //
#include "Intern.hpp"
Intern::Intern()
{
}
Intern::Intern(Intern const&src)
{
*this = src;
}
Intern::~Intern()
{
}
Intern &Intern::operator = (Intern const &src)
{
(void)src;
return *this;
}
Form *Intern::makeForm(std::string form, std::string target)
{
Form *newForm[3] = {new ShrubberyCreationForm(target), new RobotomyRequestForm(target), new PresidentialPardonForm(target)};
std::string str[3] = {"shrubbery creation", "robotomy request", "presidential pardon"};
for (int i = 0; i < 3; i++)
{
if (form == str[i])
{
for (int j = 0; j < 3; j++)
if (j != i)
delete newForm[j];
return newForm[i];
}
}
throw Intern::invalid();
}
std::ostream &operator << (std::ostream &o, Intern &src)
{
(void)src;
o << "I NEED A JOB!!!" << std::endl;
return o;
}
Intern::invalid::invalid(void)
{
}
Intern::invalid::invalid(const invalid &src)
{
*this = src;
}
Intern::invalid::~invalid(void) throw()
{
}
Intern::invalid &Intern::invalid::operator = (const invalid &rhs)
{
(void)rhs;
return *this;
}
const char *Intern::invalid::what() const throw()
{
return "Invalid parameter passed to intern! He dosen't know what to do with this crap!";
}
|
[
"[email protected]"
] | |
be99832a278b5fccae01a15047f156842eba3078
|
c312e781f9fea0434b052479fba5e86d9c48fc77
|
/ofxLoopin/src/util/ofxLoopinJSON.hpp
|
12e0d96a7d1e88912c2cc6271eb59bdeb489100f
|
[] |
no_license
|
koopero/loopin-native
|
53a428b21e69bdb077e11530214d2da584f3ecd5
|
4101fb910b5fdd16c702396cf911ed48ab3eb4f4
|
refs/heads/master
| 2023-07-22T11:22:28.482105 | 2021-02-27T09:15:12 | 2021-02-27T09:15:12 | 62,488,388 | 0 | 0 | null | 2020-04-27T08:19:36 | 2016-07-03T08:44:05 |
C++
|
UTF-8
|
C++
| false | false | 315 |
hpp
|
#pragma once
#include "ofJson.h"
/**
Wrapper for ofJson.as_boolean(), with more javascript-style conversion
from object, array and string.
*/
bool ofxLoopinJSONToBool( const ofJson & value );
/**
Same deal, but take a memebr key
*/
bool ofxLoopinJSONToBool( const ofJson & value, const std::string & key );
|
[
"[email protected]"
] | |
27d0c433a89971464db611db8c41aefca1c921b3
|
12d28b5b3fa8b856f8604ca1307746d678affa69
|
/观察者模式/observer.h
|
012d122b8c506b7f785a5e1e73a55d9e5810ee27
|
[] |
no_license
|
wangzhengyang/DesignPattern
|
d92c9c8f7aa0cae29f9ab0552af248f75550bdfd
|
cab3796603d942c22daff4e2fe9e11ab35c00110
|
refs/heads/master
| 2022-08-18T14:22:50.361881 | 2020-05-17T15:16:49 | 2020-05-17T15:16:49 | 255,211,328 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 194 |
h
|
#ifndef _OBSERVER_H
#define _OBSERVER_H
#include <iostream>
#include <list>
class Observer{
private:
//...
public:
Observer(){}
virtual ~Observer(){}
virtual void Update() = 0;
};
#endif
|
[
"[email protected]"
] | |
4218a28a7e0a11efbff061539c76025f625f7c54
|
5c799fccb82b6fa6cb373ef48527ceeaf0d6a023
|
/src/envoy/http/authn/http_filter.cc
|
5bddf17b272a1ec13b94993887805d047b3490df
|
[
"Apache-2.0"
] |
permissive
|
lei-tang/proxy
|
ed6bd3b00183ee7d48abba7895fef79a895ce265
|
a61c68b58b989ce93163c4df7588cc688d52250e
|
refs/heads/master
| 2023-04-27T13:22:52.119403 | 2018-04-03T21:27:40 | 2018-04-03T21:27:40 | 117,921,130 | 0 | 0 | null | 2018-01-18T02:33:40 | 2018-01-18T02:33:39 | null |
UTF-8
|
C++
| false | false | 5,221 |
cc
|
/* Copyright 2018 Istio Authors. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "src/envoy/http/authn/http_filter.h"
#include "authentication/v1alpha1/policy.pb.h"
#include "common/http/utility.h"
#include "envoy/config/filter/http/authn/v2alpha1/config.pb.h"
#include "src/envoy/http/authn/origin_authenticator.h"
#include "src/envoy/http/authn/peer_authenticator.h"
#include "src/envoy/utils/authn.h"
#include "src/envoy/utils/utils.h"
using istio::envoy::config::filter::http::authn::v2alpha1::FilterConfig;
namespace iaapi = istio::authentication::v1alpha1;
namespace Envoy {
namespace Http {
namespace Istio {
namespace AuthN {
AuthenticationFilter::AuthenticationFilter(const FilterConfig& filter_config)
: filter_config_(filter_config) {}
AuthenticationFilter::~AuthenticationFilter() {}
void AuthenticationFilter::onDestroy() {
ENVOY_LOG(debug, "Called AuthenticationFilter : {}", __func__);
}
FilterHeadersStatus AuthenticationFilter::decodeHeaders(HeaderMap& headers,
bool) {
ENVOY_LOG(debug, "Called AuthenticationFilter : {}", __func__);
state_ = State::PROCESSING;
filter_context_.reset(new Istio::AuthN::FilterContext(
&headers, decoder_callbacks_->connection()));
authenticator_ = createPeerAuthenticator(
filter_context_.get(),
[this](bool success) { onPeerAuthenticationDone(success); });
authenticator_->run();
if (state_ == State::COMPLETE) {
return FilterHeadersStatus::Continue;
}
stopped_ = true;
return FilterHeadersStatus::StopIteration;
}
void AuthenticationFilter::onPeerAuthenticationDone(bool success) {
ENVOY_LOG(debug, "{}: success = {}", __func__, success);
if (success) {
authenticator_ = createOriginAuthenticator(
filter_context_.get(),
[this](bool success) { onOriginAuthenticationDone(success); });
authenticator_->run();
} else {
rejectRequest("Peer authentication failed.");
}
}
void AuthenticationFilter::onOriginAuthenticationDone(bool success) {
ENVOY_LOG(debug, "{}: success = {}", __func__, success);
if (success) {
// Put authentication result to headers.
if (filter_context_ != nullptr) {
Utils::Authentication::SaveResultToHeader(
filter_context_->authenticationResult(), filter_context_->headers());
}
continueDecoding();
} else {
rejectRequest("Origin authentication failed.");
}
}
FilterDataStatus AuthenticationFilter::decodeData(Buffer::Instance&, bool) {
ENVOY_LOG(debug, "Called AuthenticationFilter : {}", __func__);
ENVOY_LOG(debug,
"Called AuthenticationFilter : {} FilterDataStatus::Continue;",
__FUNCTION__);
if (state_ == State::PROCESSING) {
return FilterDataStatus::StopIterationAndWatermark;
}
return FilterDataStatus::Continue;
}
FilterTrailersStatus AuthenticationFilter::decodeTrailers(HeaderMap&) {
ENVOY_LOG(debug, "Called AuthenticationFilter : {}", __func__);
if (state_ == State::PROCESSING) {
return FilterTrailersStatus::StopIteration;
}
return FilterTrailersStatus::Continue;
}
void AuthenticationFilter::setDecoderFilterCallbacks(
StreamDecoderFilterCallbacks& callbacks) {
ENVOY_LOG(debug, "Called AuthenticationFilter : {}", __func__);
decoder_callbacks_ = &callbacks;
}
void AuthenticationFilter::continueDecoding() {
if (state_ != State::PROCESSING) {
ENVOY_LOG(error, "State {} is not PROCESSING.", state_);
return;
}
state_ = State::COMPLETE;
if (stopped_) {
decoder_callbacks_->continueDecoding();
}
}
void AuthenticationFilter::rejectRequest(const std::string& message) {
if (state_ != State::PROCESSING) {
ENVOY_LOG(error, "State {} is not PROCESSING.", state_);
return;
}
state_ = State::REJECTED;
Utility::sendLocalReply(*decoder_callbacks_, false, Http::Code::Unauthorized,
message);
}
std::unique_ptr<Istio::AuthN::AuthenticatorBase>
AuthenticationFilter::createPeerAuthenticator(
Istio::AuthN::FilterContext* filter_context,
const Istio::AuthN::AuthenticatorBase::DoneCallback& done_callback) {
return std::make_unique<Istio::AuthN::PeerAuthenticator>(
filter_context, done_callback, filter_config_.policy());
}
std::unique_ptr<Istio::AuthN::AuthenticatorBase>
AuthenticationFilter::createOriginAuthenticator(
Istio::AuthN::FilterContext* filter_context,
const Istio::AuthN::AuthenticatorBase::DoneCallback& done_callback) {
return std::make_unique<Istio::AuthN::OriginAuthenticator>(
filter_context, done_callback, filter_config_.policy());
}
} // namespace AuthN
} // namespace Istio
} // namespace Http
} // namespace Envoy
|
[
"[email protected]"
] | |
9c0fe59a0f66968011bbe8db39eb3f3032c75c92
|
051ebea87bd1476c1e5bd35fc9d59560c84f71d1
|
/google/cloud/storage/internal/object_streambuf.h
|
ad796952e0e4b4f8e596f80430e1da0d0b2a8eb4
|
[
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference"
] |
permissive
|
past-due/google-cloud-cpp
|
fe02bb926a1f24966937f39096faa8d61005ad66
|
19c92f3b92465316f5dd64fdf169d8b50508d119
|
refs/heads/master
| 2020-05-05T04:35:22.777873 | 2019-04-05T22:04:05 | 2019-04-05T22:04:05 | 179,717,108 | 0 | 0 | null | 2019-04-05T16:25:52 | 2019-04-05T16:25:51 | null |
UTF-8
|
C++
| false | false | 5,144 |
h
|
// Copyright 2018 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_INTERNAL_OBJECT_STREAMBUF_H_
#define GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_INTERNAL_OBJECT_STREAMBUF_H_
#include "google/cloud/status_or.h"
#include "google/cloud/storage/internal/http_response.h"
#include <iostream>
namespace google {
namespace cloud {
namespace storage {
inline namespace STORAGE_CLIENT_NS {
class ObjectMetadata;
namespace internal {
/**
* Defines a compilation barrier for libcurl.
*
* We do not want to expose the libcurl objects through `ObjectReadStream`,
* this class abstracts away the implementation so applications are not impacted
* by the implementation details.
*/
class ObjectReadStreambuf : public std::basic_streambuf<char> {
public:
ObjectReadStreambuf() : std::basic_streambuf<char>() {}
~ObjectReadStreambuf() override = default;
ObjectReadStreambuf(ObjectReadStreambuf&&) noexcept = delete;
ObjectReadStreambuf& operator=(ObjectReadStreambuf&&) noexcept = delete;
ObjectReadStreambuf(ObjectReadStreambuf const&) = delete;
ObjectReadStreambuf& operator=(ObjectReadStreambuf const&) = delete;
virtual void Close() = 0;
virtual bool IsOpen() const = 0;
virtual Status const& status() const = 0;
virtual std::string const& received_hash() const = 0;
virtual std::string const& computed_hash() const = 0;
virtual std::multimap<std::string, std::string> const& headers() const = 0;
};
/**
* A read stream in a permanent error state.
*/
class ObjectReadErrorStreambuf : public ObjectReadStreambuf {
public:
explicit ObjectReadErrorStreambuf(Status status)
: status_(std::move(status)) {}
void Close() override {}
bool IsOpen() const override { return false; }
Status const& status() const override { return status_; }
std::string const& received_hash() const override { return received_hash_; }
std::string const& computed_hash() const override { return computed_hash_; }
std::multimap<std::string, std::string> const& headers() const override {
return headers_;
}
protected:
int_type underflow() override { return traits_type::eof(); }
private:
Status status_;
std::string received_hash_;
std::string computed_hash_;
std::multimap<std::string, std::string> headers_;
};
/**
* Defines a compilation barrier for libcurl.
*
* We do not want to expose the libcurl objects through `ObjectWriteStream`,
* this class abstracts away the implementation so applications are not impacted
* by the implementation details.
*/
class ObjectWriteStreambuf : public std::basic_streambuf<char> {
public:
ObjectWriteStreambuf() : std::basic_streambuf<char>() {}
~ObjectWriteStreambuf() override = default;
ObjectWriteStreambuf(ObjectWriteStreambuf&& rhs) noexcept = delete;
ObjectWriteStreambuf& operator=(ObjectWriteStreambuf&& rhs) noexcept = delete;
ObjectWriteStreambuf(ObjectWriteStreambuf const&) = delete;
ObjectWriteStreambuf& operator=(ObjectWriteStreambuf const&) = delete;
StatusOr<HttpResponse> Close();
virtual bool IsOpen() const = 0;
virtual bool ValidateHash(ObjectMetadata const& meta) = 0;
virtual std::string const& received_hash() const = 0;
virtual std::string const& computed_hash() const = 0;
/// The session id, if applicable, it is empty for non-resumable uploads.
virtual std::string const& resumable_session_id() const = 0;
/// The next expected byte, if applicable, always 0 for non-resumable uploads.
virtual std::uint64_t next_expected_byte() const = 0;
protected:
virtual StatusOr<HttpResponse> DoClose() = 0;
};
/**
* A write stream in a permanent error state.
*/
class ObjectWriteErrorStreambuf : public ObjectWriteStreambuf {
public:
explicit ObjectWriteErrorStreambuf(Status status)
: status_(std::move(status)) {}
bool IsOpen() const override { return is_open_; }
bool ValidateHash(ObjectMetadata const& meta) override { return false; }
std::string const& received_hash() const override { return string_; }
std::string const& computed_hash() const override { return string_; }
std::string const& resumable_session_id() const override { return string_; }
std::uint64_t next_expected_byte() const override { return 0; }
protected:
StatusOr<HttpResponse> DoClose() override {
is_open_ = false;
return status_;
}
private:
bool is_open_ = true;
Status status_;
std::string string_;
};
} // namespace internal
} // namespace STORAGE_CLIENT_NS
} // namespace storage
} // namespace cloud
} // namespace google
#endif // GOOGLE_CLOUD_CPP_GOOGLE_CLOUD_STORAGE_INTERNAL_OBJECT_STREAMBUF_H_
|
[
"[email protected]"
] | |
55202a5071f1d24c078afff9766f3189fc877ef1
|
abe2fc656193cbedfc64ac37b99d849b81caa61b
|
/source/tensor/function/Softmax.cpp
|
699e49a33a01334dd9819f7429bcd2113d0aaafd
|
[
"Apache-2.0"
] |
permissive
|
Luoyingfeng8/NiuTrans.Tensor
|
21bafc5d336790ed592697b6069e77cb2e50af89
|
f7cdf7964b5e4bb700b2ef3e5542145d2532dc87
|
refs/heads/master
| 2020-07-11T20:30:18.809597 | 2019-06-17T13:51:53 | 2019-06-17T13:51:53 | 204,638,431 | 1 | 0 | null | 2019-08-27T14:46:37 | 2019-08-27T06:46:36 | null |
UTF-8
|
C++
| false | false | 10,602 |
cpp
|
/* NiuTrans.Tensor - an open-source tensor library
* Copyright (C) 2017, Natural Language Processing Lab, Northestern University.
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* $Created by: XIAO Tong (email: [email protected]) 2018-04-27
*/
#include <math.h>
#include "Softmax.h"
#include "Softmax.cuh"
#include "../XName.h"
#include "../XUtility.h"
#include "../core/reduce/ReduceSum.h"
#include "../core/reduce/ReduceMax.h"
namespace nts { // namespace nts(NiuTrans.Tensor)
/*
softmax y = e^x / \sum_{i} e^{x_i}
>> x - input vector
>> y - result
>> leadDim - leading dimension (along which we perform reduction)
*/
void _Softmax(const XTensor * x, XTensor * y, int leadDim)
{
if(leadDim < 0)
leadDim = x->order - 1;
int leadDimRDI = x->order - leadDim - 1;
if(!x->isSparse && !y->isSparse && x->dataType == y->dataType){
int * dimSize = new int[x->order - 1];
for(int i = 0; i < x->order; i++){
if(i < leadDim)
dimSize[i] = x->dimSize[i];
else if(i > leadDim)
dimSize[i - 1] = x->dimSize[i];
}
XMem * mem = x->mem;
XTensor * max = NULL;
XTensor * sum = NULL;
max = NewTensorBuf(x->order - 1, dimSize, x->dataType, x->denseRatio, x->devID, mem);
sum = NewTensorBuf(x->order - 1, dimSize, x->dataType, x->denseRatio, x->devID, mem);
_ReduceMax(x, max, leadDim);
_ReduceSum(x, sum, leadDim, max, 1.0F, true);
if(x->devID >= 0){
#ifdef USE_CUDA
_CudaSoftmaxSumMax(x, y, leadDim, sum, max);
#else
ShowNTErrors("Please specify USE_CUDA and recompile the code!");
#endif
}
else{
CheckNTErrors((x->dataType == DEFAULT_DTYPE), "TODO!");
int dimensionSize = y->dimSizeRDI[leadDimRDI];
int stride = 1;
int blockSize = 1;
int blockNum = 1;
for(int i = 0; i < leadDimRDI; i++)
stride *= y->dimSizeRDI[i];
blockSize = stride * dimensionSize;
blockNum = y->unitNum / blockSize;
for(int k = 0; k < blockNum; k++){
int m = stride;
int n = dimensionSize;
int blockOffset = k * blockSize;
int blockOffsetMax = k * blockSize / dimensionSize;
DTYPE * ip = (DTYPE*)x->data + blockOffset;
DTYPE * op = (DTYPE*)y->data + blockOffset;
DTYPE * mp = (DTYPE*)max->data + blockOffsetMax;
DTYPE * sp = (DTYPE*)sum->data + blockOffsetMax;
for(int j = 0; j < m; j++){
DTYPE sumValue = sp[j];
if(sumValue == 0){
for(int i = 0; i < n; i++)
op[i * m + j] = 0;
}
else{
for(int i = 0; i < n; i++){
DTYPE r = (DTYPE)exp(ip[i * m + j] - mp[j])/sp[j];
if (r > (DTYPE)1.0F)
r = (DTYPE)1.0F;
else if (r < 0)
r = 0;
op[i * m + j] = r;
}
}
}
}
}
DelTensorBuf(sum);
DelTensorBuf(max);
delete[] dimSize;
}
else
ShowNTErrors("TODO!");
}
/*
softmax y = e^x / \sum_{i} e^{x_i} (return an XTensor structure)
make a new tensor to keep the result and return it
>> x - input vector
>> leadDim - leading dimension (along which we perform reduction)
<< return - y
*/
XTensor Softmax(const XTensor &x, int leadDim)
{
int ld = leadDim;
if (ld < 0)
ld = x.order - 1;
XTensor y(&x);
y.SetTMPFlag();
/* call _Softmax function */
_Softmax(&x, &y, ld);
/* tensor connection */
XLink::MakeLink(&x, NULL, &y, FUNC_SOFTMAX);
XLink::AddParamToHeadInt(&y, ld);
return y;
}
/*
backward computation for dense tensors
dE/dx = dE/dy * dy/dx
softmax: y_i = e^{x_i} / \sum_{k} e^{x_k}
dy_i/dx_j = y_i * (\delta(i,j) - y_j)
for cross-entropy error function,
dE/dy_i = -gold_i / y_i
then
dE/dx_j = -gold_j + y_j
See more details in LogSoftmaxBackward(...)
>> gold - gold standard to measure error (or loss)
>> y - output of the function
>> x - input of the function
>> dedy - dE/dy
>> dedx - dE/dx
>> lossName - type of loss function, e.g., cross entropy
>> leadDim - leading dimension (along which we perform reduction)
*/
void _SoftmaxBackward(XTensor * gold, XTensor * y, XTensor * x,
XTensor * dedy, XTensor * dedx,
XTensor * padding, int leadDim,
LOSS_FUNCTION_NAME lossName)
{
CheckNTErrors(dedx->isSparse == false, "The gradient tensor must be dense!");
CheckNTErrors(gold != NULL || lossName == NOLOSS, "Gold standard is required for computing loss!");
if(leadDim < 0)
leadDim = y->order - 1;
int leadDimRDI = y->order - leadDim - 1;
#ifdef USE_CUDA
if(y->devID >= 0){
_CudaSoftmaxBackward(gold, y, x, dedy, dedx, padding, leadDim, lossName);
return;
}
#endif
int dimensionSize = y->dimSizeRDI[leadDimRDI];
int stride = 1;
int blockSize = 1;
int blockNum = 1;
for(int i = 0; i < leadDimRDI; i++)
stride *= y->dimSizeRDI[i];
blockSize = stride * dimensionSize;
blockNum = y->unitNum / blockSize;
if(x->dataType == DEFAULT_DTYPE && y->dataType == DEFAULT_DTYPE)
{
DTYPE * gp = gold != NULL ? (DTYPE*)gold->data : NULL;
DTYPE * op = (DTYPE*)y->data;
DTYPE * sp = (DTYPE*)dedx->data;
DTYPE * yp = NULL;
if(lossName == CROSSENTROPY){
if(gold->isSparse){
CheckNTErrors((gold->order == 2), "TODO!");
int size = dimensionSize * stride;
/* dE/dx_j = y_j */
for(int j = 0; j < size; j++){
*(sp+j) = *(op+j);
}
/* for j \in gold (sparse), dE/dx_j += -gold_j */
int num = gold->GetNonzeroSize();
for(int i = 0; i < num; i++){
int key = gold->GetKeyInSparse(i);
DTYPE value = gold->GetInSparse(i);
int offset = key;
if(key >= 0 && key < size)
*(sp+offset) += -value;
}
}
else{
CheckNTErrors((XTensor::IsSameShaped(gold, y)), "The tensors must be of the same size!");
for(int k = 0; k < blockNum; k++){
gp = (DTYPE*)gold->data + k * blockSize;
op = (DTYPE*)y->data + k * blockSize;
sp = (DTYPE*)dedx->data + k * blockSize;
int size = stride * dimensionSize;
/* dE/dx_j = -gold_j + y_j */
for(int j = 0; j < size; j++){
*(sp+j) = -(*(gp+j)) + *(op+j);
}
}
}
}
else if(lossName == SQUAREDERROR){
/*
dE/dx_j = -gold_j - y_j
it is actually the same as that in cross entropy.
*/
if(gold->isSparse){
CheckNTErrors((gold->order == 2), "TODO!");
int size = dimensionSize * stride;
/* dE/dx_j = y_j */
for(int j = 0; j < size; j++){
*(sp+j) = *(op+j);
}
/* for j \in gold (sparse), dE/dx_j += -gold_j */
int num = gold->GetNonzeroSize();
for(int i = 0; i < num; i++){
int key = gold->GetKeyInSparse(i);
DTYPE value = gold->GetInSparse(i);
int offset = key;
if(key >= 0 && key < size)
*(sp+offset) += -value;
}
}
else{
CheckNTErrors((XTensor::IsSameShaped(gold, y)), "The tensors must be of the same size!");
for(int k = 0; k < blockNum; k++){
gp = (DTYPE*)gold->data + k * blockSize;
op = (DTYPE*)y->data + k * blockSize;
sp = (DTYPE*)dedx->data + k * blockSize;
int size = stride * dimensionSize;
/* dE/dx_j = -gold_j + y_j */
for(int j = 0; j < size; j++){
*(sp+j) = -(*(gp+j)) + *(op+j);
}
}
}
}
else if(lossName == NOLOSS){
/*
for softmax:
y_i = e^{x_i} / \sum_{k} e^{x_k}
we have
dy_i/dx_j = y_i * (\delta(i,j) - y_j)
Then
dE/dx_j = \sum_i dE/dy_i * y_i * (\delta(i,j) - y_j)
= dE/dy_j * y_j - y_j * \beta
= y_j * (dE/dy_j - \beta)
where
\beta = \sum_i (dE/dy_i * y_i)
*/
for(int m = 0; m < blockNum; m++){
yp = (DTYPE*)dedy->data + m * blockSize;
op = (DTYPE*)y->data + m * blockSize;
sp = (DTYPE*)dedx->data + m * blockSize;
int nCols = stride;
for(int k = 0; k < stride; k++){
/* \beta = \sum_i (dE/dy_i * y_i) */
DTYPE beta = 0;
for(int i = 0; i < dimensionSize; i++)
beta += yp[i * nCols + k] * op[i * nCols + k];
/* dE/ds_j = y_j * (dE/dy_j - \beta) */
for(int j = 0; j < dimensionSize; j++)
sp[j * nCols + k] = op[j * nCols + k] * (yp[j * nCols + k] - beta);
}
}
}
else
ShowNTErrors("TODO!");
}
else
ShowNTErrors("TODO!");
}
} // namespace nts(NiuTrans.Tensor)
|
[
"[email protected]"
] | |
cc145093240dbf524c77ce96712af918926428e9
|
4c626c943b6af56524c6599b64451722ee2e9629
|
/aep/sources/checkers/resources/aep_checker_resources.hpp
|
f75b56cdf53308765a434a1df1bb82df55fc9e1b
|
[] |
no_license
|
kirillPshenychnyi/AEP
|
96cec51a4c579b2430b8c93cace5e25003c64219
|
07d9f3deb47514043a8a1cb0c5ff6091737c3d47
|
refs/heads/master
| 2018-08-31T16:59:08.415648 | 2018-06-10T22:21:04 | 2018-06-10T22:21:04 | 117,731,321 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,692 |
hpp
|
#ifndef __AEP_CHECKER_RESOURCES_HPP__
#define __AEP_CHECKER_RESOURCES_HPP__
/***************************************************************************/
namespace Aep {
namespace Resources {
/***************************************************************************/
namespace CommonValues {
/***************************************************************************/
extern const char Enable[];
extern const char Reset[];
/***************************************************************************/
}
/***************************************************************************/
namespace Separators {
/***************************************************************************/
extern const char ParenthesesOpen[];
extern const char ParenthesesClose[];
extern const char Space;
extern const char Coma[];
/***************************************************************************/
}
/***************************************************************************/
namespace FullCaseSynDirecriveChecker {
/***************************************************************************/
extern const char CheckerInstanceName[];
extern const char CheckTerm[];
extern const char OrItem[];
extern const char CheckExpression[];
extern const char CheckExpressionWire[];
extern const char FireWire[];
extern const char Message[];
extern const char CaseSelWire[];
/***************************************************************************/
}
/***************************************************************************/
namespace ParallelCaseSynDirecriveChecker {
/***************************************************************************/
extern const char CheckerInstanceName[];
extern const char CheckTerm[];
extern const char CheckExpression[];
extern const char CheckExpressionWire[];
extern const char FireWire[];
extern const char Message[];
extern const char CaseSelWire[];
/***************************************************************************/
}
/***************************************************************************/
namespace RangeBoundChecker {
/***************************************************************************/
extern const char CheckExpression[];
extern const char CheckExpressionWire[];
extern const char FireWire[];
extern const char Message[];
extern const char CheckerInstanceName[];
/***************************************************************************/
}
/***************************************************************************/
}
}
/***************************************************************************/
#endif // !__AEP_CHECKER_RESOURCES_HPP__
|
[
"[email protected]"
] | |
01fa8562be5d9c5b83525bd0f0059af0c323f7e5
|
f33c3777289068e6b30e1305a246ae2fe84e0ad8
|
/src/graphics/painter_p.h
|
421e1d882e8d313e604985c4efa2002717e64cdb
|
[
"BSD-2-Clause"
] |
permissive
|
gamaral/marshmallow_h
|
c8fdade0082d2d7d50fe040016f4a5922055bbc1
|
267ba11a11a48ad1207e500c5bc7633a8c9093bc
|
refs/heads/staging
| 2021-01-17T12:10:18.853443 | 2016-01-01T23:23:07 | 2016-01-01T23:23:07 | 1,540,144 | 28 | 10 |
NOASSERTION
| 2020-07-07T18:22:06 | 2011-03-29T05:37:32 |
C
|
UTF-8
|
C++
| false | false | 3,243 |
h
|
/*
* Copyright (c) 2012-2013, Guillermo A. Amaral B. (gamaral) <[email protected]>
* All rights reserved.
*
* This file is part of Marshmallow Game Engine.
*
* 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.
*
* THIS SOFTWARE IS PROVIDED BY THE 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 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.
*
* The views and conclusions contained in the software and documentation are
* those of the authors and should not be interpreted as representing official
* policies, either expressed or implied, of the project as a whole.
*/
#pragma once
/*!
* @file
*
* @author Guillermo A. Amaral B. (gamaral) <[email protected]>
*/
#ifndef MARSHMALLOW_GRAPHICS_PAINTER_P_H
#define MARSHMALLOW_GRAPHICS_PAINTER_P_H 1
#include "graphics/painter.h"
MARSHMALLOW_NAMESPACE_BEGIN
namespace Graphics { /************************************ Graphics Namespace */
/**** IMPLEMENTATION NOTES *****************************************************
*
* Painter::Initialize and Painter::Finalize may be called multiple times
* by the Viewport.
*
*/
namespace Painter { /**************************** Graphics::Painter Namespace */
/*
* Painter::Initialized is called after getting a valid display by the
* Viewport implementation, all resources constructed here must be
* cleanly destroyed during Painter::Finalize.
*/
MARSHMALLOW_GRAPHICS_EXPORT
void Initialize(void);
/*
* Painter::Finalize is called prior to display destruction by the
* Viewport, all resources should be cleanly destroyed.
*
* The Painter must be ready to get reinitialized at any moment.
*/
MARSHMALLOW_GRAPHICS_EXPORT
void Finalize(void);
/*
* Painter::Render is called pre-rendering.
*/
MARSHMALLOW_GRAPHICS_EXPORT
void Render(void);
/*
* Painter::Reset is called post-rendering. The painter should
* automatically reload the View Projection Matrix at this time.
*/
MARSHMALLOW_GRAPHICS_EXPORT
void Reset(void);
} /********************************************** Graphics::Painter Namespace */
} /******************************************************* Graphics Namespace */
MARSHMALLOW_NAMESPACE_END
#endif
|
[
"[email protected]"
] | |
06290baf484f2f0013beec93d056ddd4d967a72f
|
0b1111e870b496aae0d6210806eebf1c942c9d3a
|
/LinearAlgebra/MatrixIO.h
|
44c1691626b35f64a8b4f2f4e055d0ad7dc1978d
|
[
"WTFPL"
] |
permissive
|
victorliu/Templated-Numerics
|
8ca3fabd79435fa40e95e9c8c944ecba42a0d8db
|
35ca6bb719615d5498a450a2d58e2aa2bb7ef5f9
|
refs/heads/master
| 2016-09-05T16:32:22.250276 | 2009-12-30T07:48:03 | 2009-12-30T07:48:03 | 318,857 | 3 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,076 |
h
|
#ifndef _MATRIX_IO_H_
#define _MATRIX_IO_H_
#include <iostream>
#include "MatrixInterfaces.h"
#include "MatrixViews.h"
// Dense Mathematica output
template <class T>
typename IsReadableMatrix<typename T::readable_matrix,
std::ostream&
>::type
operator<<(std::ostream& os, const T &view){
os << "{" << std::endl;
const size_t M = view.Rows(), N = view.Cols();
for(size_t i = 0; i < M; ++i){
os << "{";
for(size_t j = 0; ; ++j){
os << view.Get(i,j);
if(N-1 == j){
if(i < M-1){
os << "}," << std::endl;
}else{
os << "}" << std::endl;
}
break;
}else{
os << ", ";
}
}
}
os << "}";
return os;
}
// Dense Mathematica output
template <class T>
typename IsReadableVector<typename T::readable_vector,
std::ostream&
>::type
operator<<(std::ostream& os, const T &view){
os << "{";
const size_t N = view.size();
for(size_t i = 0; ; ++i){
os << view.Get(i);
if(N-1 == i){
os << "}";
break;
}else{
os << ", ";
}
}
return os;
}
#endif // _MATRIX_IO_H_
|
[
"[email protected]"
] | |
28c36cb9a1a0f69b654b52ec0ba0251c8d73409e
|
727879337125018590abce5a2a5be6b9b9d4790a
|
/src/absorb_only.h
|
36e5dfa723b49e3da2571af706abb46557553426
|
[] |
no_license
|
JasonShiao/MCS_Light_Propagation
|
f4088187977b761079f3e3bce414721a16fdc126
|
0ae959badb5846b3733e8d996fbec787c632745c
|
refs/heads/main
| 2023-03-08T09:34:49.177541 | 2023-02-04T20:54:39 | 2023-02-04T20:54:39 | 86,128,365 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 289 |
h
|
#ifndef ABSORBONLY_H_INCLUDED
#define ABSORBONLY_H_INCLUDED
#include <iostream>
#include <stdlib.h>
#include <fstream>
#include <vector>
#include <string>
#include "random_number.h"
#include "media_structure.h"
bool absorbOnly(std::string output_file);
#endif // ABSORBONLY_H_INCLUDED
|
[
"[email protected]"
] | |
6dcf7361a652a39541cf5e3bed61ced4f47a8a9d
|
96cfaaa771c2d83fc0729d8c65c4d4707235531a
|
/RecoLocalMuon/CSCCalibrateDigis/src/CSCCalibDigisProducer.h
|
deea87143a2891563649c3bbb920e8ead077a3ff
|
[] |
no_license
|
khotilov/cmssw
|
a22a160023c7ce0e4d59d15ef1f1532d7227a586
|
7636f72278ee0796d0203ac113b492b39da33528
|
refs/heads/master
| 2021-01-15T18:51:30.061124 | 2013-04-20T17:18:07 | 2013-04-20T17:18:07 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,303 |
h
|
#ifndef CSCCalibrateDigis_CSCCalibDigisProducer_h
#define CSCCalibrateDigis_CSCCalibDigisProducer_h
/** \class CSCCalibDigisProducer
*
* Reads in calibration database and computes the average strip gain G for whole CSC System.
* Then, it loops over all CSCStripDigis, and it scales the ADC counts of each channel i by
* a factor G/g_i, where g_i is the gain for strip i.
*
* A new CSCStripDigi is then formed and added to a new CSCStripDigiCollection
*
* \author Dominique Fortin - UCR
*
*/
#include <memory>
#include <string>
#include "FWCore/Framework/interface/Frameworkfwd.h"
#include "FWCore/Framework/interface/EDProducer.h"
#include "FWCore/Framework/interface/Event.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
class CSCMakeStripDigiCollections;
class CSCMakeWireDigiCollections;
class CSCCalibDigisProducer : public edm::EDProducer {
public:
explicit CSCCalibDigisProducer(const edm::ParameterSet&);
~CSCCalibDigisProducer();
virtual void produce(edm::Event&, const edm::EventSetup&);
private:
// Keep index of event processed
int iev;
// Input parameters from .cfg file:
bool debug;
std::string RawDataLabel;
// Classe nicknames:
CSCMakeStripDigiCollections* mkStripCollect_;
CSCMakeWireDigiCollections* mkWireCollect_;
};
#endif
|
[
"[email protected]"
] | |
772262faf85a32b47229b98ddaad26141addfb97
|
29c0dd8216986f42b955cfc27b3b77f5c160c8f6
|
/src/Main/Manager.h
|
941f477be06748158b03ac4c7828ff081da4cde2
|
[] |
no_license
|
ImanolGo/AudioOnsetImagesApp
|
c878299c86dddfb9d90a6ee361e93f45b4b17f25
|
7ff8217446582e59bd5be0242f6e6d513c8c3152
|
refs/heads/master
| 2022-11-20T17:41:32.964808 | 2022-11-07T09:48:00 | 2022-11-07T09:48:00 | 52,681,287 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 910 |
h
|
/*
* Manager.h
*
* Created by Imanol Gomez on 17/06/15.
*
*/
#pragma once
//========================== class Manager ==============================
//============================================================================
/** \class Manager Manager.h
* \brief Base class for all managers.
* \details Provides basic member attributes which are in common for all managers.
*/
//==============================================================================
class Manager
{
public:
//! Constructor
Manager(): m_initialized(false) {}
//! Destructor
virtual ~Manager() {}
//! Set-up the manager
virtual void setup() {m_initialized=true;}
//! updates the manager
virtual void update() {}
//==========================================================================
protected:
bool m_initialized; ///< defines if the manager has been already been initialized
};
|
[
"[email protected]"
] | |
e0e612421955fed44211aeb5685dd28169da82af
|
e5614c36fd324f2e214ff05aaf2bf7230443e0b5
|
/HackerEarth/Samu and Special Coprime Numbers.cpp
|
b23ed956a191689c96fcd72ece0acbd5e1140ab2
|
[] |
no_license
|
njrafi/Competitive-Programming-Solutions
|
a9cd3ceae430e6b672c02076f80ecb94065ff6d8
|
86d167c355813157b0a0a8382b6f8538f29d4599
|
refs/heads/master
| 2020-07-30T22:18:46.473308 | 2019-10-06T18:12:36 | 2019-10-06T18:12:36 | 210,377,979 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 3,528 |
cpp
|
#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#define gc getchar
#define pc putchar
#else
#define gc getchar_unlocked
#define pc putchar_unlocked
#endif
using namespace std;
#define vi vector<int>
#define si set<int>
#define vs vector<string>
#define pii pair<int,int>
#define vpi vector<pii>
#define pri priority_queue<int>
#define rev_pri priority_queue<int,vector<int>,greater<int> >
#define mpi map<int,int>
#define i64 long long int
#define endl '\n'
#define pi acos(-1)
#define all(v) v.begin(),v.end()
#define pb push_back
#define mp make_pair
#define mod 1000000007
#define inf INT_MAX/2
#define infll LLONG_MAX/3
#define For(i,n) for(int i=0;i<n;i++)
#define Fre(i,a,b) for(int i = a; i < b; i++)
#define sf(n) scanf("%d", &n)
#define sff(a,b) scanf("%d %d", &a, &b)
#define sfff(a,b,c) scanf("%d %d %d", &a, &b, &c)
#define pfn(n) printf("%d\n", n)
#define pfs(n) printf("%d ", n)
#define eps 1e-8
#define ff first
#define ss second
#define mem(a,b) memset(a,b,sizeof(a))
#define READ freopen("in.txt", "r", stdin)
#define WRITE freopen("out.txt", "w", stdout)
#define sz size()
#define dbg(i) printf("yo %d\n", i)
#define foreach(i,c) for(__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define sqr(a) (a) * (a)
#define clr clear()
#define CASE(a) printf("Case %d: ",a)
//int dx[] = {0,1,0,-1,1,1,-1,-1};
//int dy[] = {1,0,-1,0,1,-1,-1,1};
i64 gcd(i64 a,i64 b){if(!b)return a;return gcd(b,a%b);}
//inline void fastRead(int *a){register char c=0;while(c<33)c=gc();*a=0;while(c>33){*a=*a*10+c-'0';c=gc();}}
//inline void fastWrite(int a){char snum[20];int i=0;do{snum[i++]=a%10+48;a=a/10;}while(a!=0);i=i-1;while(i>=0)pc(snum[i--]);pc('\n');}
//i64 bigmod(i64 num,i64 n){if(n==0)return 1;i64 x=bigmod(num,n/2);x=x*x%mod;if(n%2==1)x=x*num%mod;return x;}
//i64 modinverse(i64 num){return bigmod(num,mod-2)%mod;}
//i64 po(i64 a,i64 b){i64 ans=1;while(b--)ans *= a;return ans;}
//i64 ncr(i64 n,i64 r){if(n==r)return 1;if(r==1)return n;if(dp[n][r]!=-1)return dp[n][r];return dp[n][r]=ncr(n-1,r)+ncr(n-1,r-1);}
// bit manipulations
//bool checkbit(int mask,int bit){return mask & (1<<bit);}
//int setbit(int mask,int bit){ return mask (1<<bit) ; }
//int clearbit(int mask,int bit){return mask & ~(1<<bit);}
//int togglebit(int mask,int bit){return mask ^ (1<<bit);}
i64 dp[20][200][2000];
int vis[20][200][2000];
vi v;
i64 f(int pos,int dsum,int sq,bool eq)
{
if(pos==-1)
return gcd(dsum,sq)==1;
if(!eq && vis[pos][dsum][sq])
return dp[pos][dsum][sq];
if(!eq)
vis[pos][dsum][sq] = 1;
int mx = v[pos] + 1;
if(!eq)
mx = 10;
i64 ans = 0;
For(i,mx)
ans += f(pos-1,dsum + i , sq + i* i , eq && i==mx-1);
if(!eq)
dp[pos][dsum][sq] = ans;
return ans;
}
i64 solve(i64 num)
{
if(!num)
return 0;
v.clr;
while(num)
{
v.pb(num%10);
num /= 10;
}
// reverse(all(v));
// For(i,v.sz)
// cout << v[i] << " ";
return f(v.sz-1,0,0,1) ;
}
int main()
{
int t;
i64 l,r;
sf(t);
while(t--)
{
cin >> l >> r;
// cout << solve(r) << endl;
//cout << solve(l-1) << endl;
cout << solve(r) - solve(l-1) << endl;
}
return 0;
}
|
[
"[email protected]"
] | |
31b3832f6109a7767babc83b1ed15f8b64774c9f
|
45c84e64a486a3c48bd41a78e28252acbc0cc1b0
|
/src/components/previews/core/previews_features.cc
|
d839a4e337b23d9b93f2563b2e6f003d3257620f
|
[
"BSD-3-Clause",
"MIT"
] |
permissive
|
stanleywxc/chromium-noupdator
|
47f9cccc6256b1e5b0cb22c598b7a86f5453eb42
|
637f32e9bf9079f31430c9aa9c64a75247993a71
|
refs/heads/master
| 2022-12-03T22:00:20.940455 | 2019-10-04T16:29:31 | 2019-10-04T16:29:31 | 212,851,250 | 1 | 2 |
MIT
| 2022-11-17T09:51:04 | 2019-10-04T15:49:33 | null |
UTF-8
|
C++
| false | false | 3,335 |
cc
|
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/previews/core/previews_features.h"
#include "build/build_config.h"
namespace previews {
namespace features {
// Kill switch (or holdback) for all previews. No previews will be allowed
// if this feature is disabled. If enabled, which specific previews that
// are enabled are controlled by other features.
const base::Feature kPreviews {
"Previews",
#if defined(OS_ANDROID) || defined(OS_LINUX)
// Previews allowed for Android (but also allow on Linux for dev/debug).
base::FEATURE_ENABLED_BY_DEFAULT
#else // !defined(OS_ANDROID) || defined(OS_LINUX)
base::FEATURE_DISABLED_BY_DEFAULT
#endif // defined(OS_ANDROID) || defined(OS_LINUX)
};
// Enables the Offline previews on android slow connections.
const base::Feature kOfflinePreviews{"OfflinePreviews",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the NoScript previews for Android.
const base::Feature kNoScriptPreviews {
"NoScriptPreviews",
#if defined(OS_ANDROID)
base::FEATURE_ENABLED_BY_DEFAULT
#else // !defined(OS_ANDROID)
base::FEATURE_DISABLED_BY_DEFAULT
#endif // defined(OS_ANDROID)
};
// Enables the Stale Previews timestamp on Previews infobars.
const base::Feature kStalePreviewsTimestamp{"StalePreviewsTimestamp",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the application of the resource loading hints when loading resources.
const base::Feature kResourceLoadingHints {
"ResourceLoadingHints",
#if defined(OS_ANDROID)
base::FEATURE_ENABLED_BY_DEFAULT
#else // !defined(OS_ANDROID)
base::FEATURE_DISABLED_BY_DEFAULT
#endif // defined(OS_ANDROID)
};
// Enables client redirects to a server-rendered lite page preview.
const base::Feature kLitePageServerPreviews{"LitePageServerPreviews",
base::FEATURE_DISABLED_BY_DEFAULT};
// Provides slow page triggering parameters.
const base::Feature kSlowPageTriggering{"PreviewsSlowPageTriggering",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the use of a pref to only trigger Offline Previews when there is a
// high chance that there is one to serve.
const base::Feature kOfflinePreviewsFalsePositivePrevention{
"OfflinePreviewsFalsePositivePrevention",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables a per-page load holdback experiment using a random coin flip.
const base::Feature kCoinFlipHoldback{"PreviewsCoinFlipHoldback_UKMOnly",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables filtering navigation URLs by suffix to exclude navigation that look
// like media resources from triggering previews. For example,
// http://chromium.org/video.mp4 would be excluded.
const base::Feature kExcludedMediaSuffixes{"PreviewsExcludedMediaSuffixes",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables DeferAllScript previews.
const base::Feature kDeferAllScriptPreviews{"DeferAllScript",
base::FEATURE_DISABLED_BY_DEFAULT};
} // namespace features
} // namespace previews
|
[
"[email protected]"
] | |
05dd4983036e9a5b01cb5102d9489c76ee6815b6
|
6a70daed8431c817f5743e0497bbd84cca7c47ff
|
/binary search tree/binary_search_tree.cpp
|
a0eb8e6505394e90dd94386a02042aeb1625ab4c
|
[] |
no_license
|
Goldent00thbrush/Basic_Algos_DStructs
|
25476653cd7cd42edb73ab2867d0a1343d3e4e6a
|
48fdb40c64a0446426707b69ebd520fa8be022db
|
refs/heads/main
| 2023-04-01T14:31:59.893799 | 2021-04-05T16:42:45 | 2021-04-05T16:42:45 | 328,444,470 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 7,026 |
cpp
|
#include "binary_search_tree.h"
#include "node.cpp"
#include <iostream>
using namespace std;
template<typename T>
binary_search_tree<T>::binary_search_tree()
{
root = nullptr;
s = 0;
}
template<typename T>
void binary_search_tree<T>::insert(T d){ // insert value into tree
s ++;
if (root == nullptr){
root = new node<T>(d);
}
else{
node<T>* curr = root, *prev=root;
int flag = 0;
while(true){
if(curr == nullptr){
curr = new node<T>(d);
if (flag == 1)
prev ->left = curr;
else if(flag ==2)
prev -> right = curr;
break;
}
else if(curr->data> d){
prev = curr;
curr = curr->left;
flag = 1;
}
else if(curr->data<d){
prev = curr;
curr = curr->right;
flag = 2;
}
}
}
}
template<typename T>
int binary_search_tree<T>::get_node_count(){ // get count of values stored
return s;
}
template<typename T>
void binary_search_tree<T>::print_values(){ // prints the values in the tree, from min to max
print_values(root);
}
template<typename T>
void binary_search_tree<T>::print_values(node<T>* root){ // prints the values in the tree, from min to max
if(root == nullptr)
return;
cout<<root->data<<endl;
print_values(root->left);
print_values(root->right);
}
template<typename T>
void binary_search_tree<T>::delete_tree(){
delete_tree(root);
root = nullptr;
}
template<typename T>
void binary_search_tree<T>::delete_tree(node<T>* node){
if (node == nullptr)
return;
delete_tree(node->left);
delete_tree(node->right);
delete node;
}
template<typename T>
bool binary_search_tree<T>::is_in_tree(T val){ // returns true if given value exists in the tree
if(is_in_tree(val, root)==nullptr)
return false;
else
return true;
}
template<typename T>
node<T>* binary_search_tree<T>::is_in_tree(T val, node<T>* n){ // returns true if given value exists in the tree
if(n == nullptr)
return nullptr;
if(n->data == val)
return n;
else if (n->data>val)
return is_in_tree(val, n->left);
else
return is_in_tree(val, n->right);
}
template<typename T>
int binary_search_tree<T>::get_height(){ // returns the height in nodes (single node's height is 1)
return get_height(root);
}
template<typename T>
int binary_search_tree<T>::get_height(node<T>* n){ // returns the height in nodes (single node's height is 1)
if (n == nullptr)
return -1;
return max(get_height(n->left), get_height(n->right))+1;
}
template<typename T>
T binary_search_tree<T>::get_min(){ // returns the minimum value stored in the tree
node<T> * curr = root;
while (curr->left != nullptr){
curr = curr ->left;
}
return curr->data;
}
template<typename T>
T binary_search_tree<T>::get_max(){ // returns the maximum value stored in the tree
node<T> * curr = root;
while (curr->right != nullptr){
curr = curr ->right;
}
return curr->data;
}
template<typename T>
bool binary_search_tree<T>::is_binary_search_tree(node<T> * root){
if(root == nullptr)
return true;
node<T>* l= root->left, *r=root->right;
if(r!= nullptr && root->data>r->data)
return false;
else if(l!= nullptr && root->data<l->data)
return false;
return is_binary_search_tree(root->left) && is_binary_search_tree(root->right)&& true;
}
template<typename T>
void binary_search_tree<T>::delete_value(T d){
if(d==root->data){
node<T>* left_branch = root->left;
node<T>* right_branch = root->right, *prev=right_branch;
//find the min in right branch
while(right_branch->left!=nullptr){
prev= right_branch;
right_branch = right_branch->left;
}
prev->left=nullptr;
root = right_branch;
root->left = left_branch;
root->right = prev;
}
else{
node<T>* n= is_in_tree(d,root);
if(n->left==nullptr && n->right==nullptr){ //leaf
node<T>* p= get_parent(d,root), *pl=p->left, *pr=p->right;
if(pl->data==d)
p->left = nullptr;
else if(pr->data==d)
p->right = nullptr;
}
else if(n->left==nullptr){//one child
node<T>* p= get_parent(d,root), *pl=p->left, *pr=p->right;
if(pl->data==d)
p->left = n->right;
else if(pr->data==d)
p->right = n->right;
}
else if(n->right==nullptr){//one child
node<T>* p= get_parent(d,root), *pl=p->left, *pr=p->right;
if(pl->data==d)
p->left = n->left;
else if(pr->data==d)
p->right = n->left;
}
else{ //2 children
node<T>* left_branch = n->left;
node<T>* right_branch = n->right, *prev=right_branch;
//find the min in right branch
while(right_branch->left!=nullptr){
prev= right_branch;
right_branch = right_branch->left;
}
prev->left=nullptr;
if(prev == right_branch || prev==left_branch)
prev = nullptr;
n = right_branch;
n->left = left_branch;
n->right = prev;
node<T>* p= get_parent(d,root), *pl=p->left, *pr=p->right;
if(pl->data==d)
p->left = n;
else if(pr->data==d)
p->right = n;
}
}
}
template<typename T>
T binary_search_tree<T>::get_successor(T val){ // returns next-highest value in tree after given value, -1 if none
node<T> * curr = root, *prev =root;
//find the node
while(true){
if(curr->data == val)
break;
else if (curr->data>val){
prev= curr;
curr = curr->left;
}
else{
prev= curr;
curr = curr->right;
}
}
if(curr->right == nullptr){
if(prev->data>val)
return prev->data;
else
return -1;
}
curr = curr->right;
return curr->data;
}
template<typename T>
node<T>* binary_search_tree<T>::get_root(){
return root;
}
template<typename T>
node<T>* binary_search_tree<T>::get_parent(T val, node<T>* curr){ // returns next-highest value in tree after given value, -1 if none
node<T> * curr_l = curr->left, *curr_r=curr->right;
//find the node
if (curr_l->data ==val)
return curr;
if(curr_r->data == val)
return curr;
if(val<curr_l->data && val<curr_r->data)
return get_parent(val, curr_l);
if (val>curr_r->data)
return get_parent(val, curr_r);
}
|
[
"[email protected]"
] | |
6dc69dabc5b62b880b19bb50f8ae052d0479ddf0
|
05c7b5d8aa0290b89d917b0bf0454d12ff4472b6
|
/src/rpcdump.cpp
|
ecf0500b6b7aa9c6e065508ab8725d666bb4c645
|
[
"MIT"
] |
permissive
|
Cryptonex/source-dev
|
1d26c15dacaf0575e3800c55d344a3a4d032269a
|
992b55d84d267b8ce31bfb70e6517288fbd49044
|
refs/heads/master
| 2021-04-15T18:35:13.899850 | 2018-04-20T12:39:48 | 2018-04-20T12:39:48 | 126,500,358 | 1 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 11,283 |
cpp
|
// Copyright (c) 2009-2012 Bitcoin Developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <iostream>
#include <fstream>
#include "init.h" // for pwalletMain
#include "bitcoinrpc.h"
#include "ui_interface.h"
#include "base58.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/variant/get.hpp>
#include <boost/algorithm/string.hpp>
#define printf OutputDebugStringF
using namespace json_spirit;
using namespace std;
void EnsureWalletIsUnlocked();
namespace bt = boost::posix_time;
// Extended DecodeDumpTime implementation, see this page for details:
// http://stackoverflow.com/questions/3786201/parsing-of-date-time-from-string-boost
const std::locale formats[] = {
std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%dT%H:%M:%SZ")),
std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%d %H:%M:%S")),
std::locale(std::locale::classic(),new bt::time_input_facet("%Y/%m/%d %H:%M:%S")),
std::locale(std::locale::classic(),new bt::time_input_facet("%d.%m.%Y %H:%M:%S")),
std::locale(std::locale::classic(),new bt::time_input_facet("%Y-%m-%d"))
};
const size_t formats_n = sizeof(formats)/sizeof(formats[0]);
std::time_t pt_to_time_t(const bt::ptime& pt)
{
bt::ptime timet_start(boost::gregorian::date(1970,1,1));
bt::time_duration diff = pt - timet_start;
return diff.ticks()/bt::time_duration::rep_type::ticks_per_second;
}
int64_t DecodeDumpTime(const std::string& s)
{
bt::ptime pt;
for(size_t i=0; i<formats_n; ++i)
{
std::istringstream is(s);
is.imbue(formats[i]);
is >> pt;
if(pt != bt::ptime()) break;
}
return pt_to_time_t(pt);
}
std::string static EncodeDumpTime(int64_t nTime) {
return DateTimeStrFormat("%Y-%m-%dT%H:%M:%SZ", nTime);
}
std::string static EncodeDumpString(const std::string &str) {
std::stringstream ret;
BOOST_FOREACH(unsigned char c, str) {
if (c <= 32 || c >= 128 || c == '%') {
ret << '%' << HexStr(&c, &c + 1);
} else {
ret << c;
}
}
return ret.str();
}
std::string DecodeDumpString(const std::string &str) {
std::stringstream ret;
for (unsigned int pos = 0; pos < str.length(); pos++) {
unsigned char c = str[pos];
if (c == '%' && pos+2 < str.length()) {
c = (((str[pos+1]>>6)*9+((str[pos+1]-'0')&15)) << 4) |
((str[pos+2]>>6)*9+((str[pos+2]-'0')&15));
pos += 2;
}
ret << c;
}
return ret.str();
}
class CTxDump
{
public:
CBlockIndex *pindex;
int64_t nValue;
bool fSpent;
CWalletTx* ptx;
int nOut;
CTxDump(CWalletTx* ptx = NULL, int nOut = -1)
{
pindex = NULL;
nValue = 0;
fSpent = false;
this->ptx = ptx;
this->nOut = nOut;
}
};
Value importprivkey(const Array& params, bool fHelp)
{
if (fHelp || params.size() < 1 || params.size() > 2)
throw runtime_error(
"importprivkey <cryptonexprivkey> [label]\n"
"Adds a private key (as returned by dumpprivkey) to your wallet.");
string strSecret = params[0].get_str();
string strLabel = "";
if (params.size() > 1)
strLabel = params[1].get_str();
CBitcoinSecret vchSecret;
bool fGood = vchSecret.SetString(strSecret);
if (!fGood) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid private key");
if (fWalletUnlockStakingOnly)
throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Wallet is unlocked for staking only.");
CKey key;
bool fCompressed;
CSecret secret = vchSecret.GetSecret(fCompressed);
key.SetSecret(secret, fCompressed);
CKeyID vchAddress = key.GetPubKey().GetID();
{
LOCK2(cs_main, pwalletMain->cs_wallet);
pwalletMain->MarkDirty();
pwalletMain->SetAddressBookName(vchAddress, strLabel);
// Don't throw error in case a key is already there
if (pwalletMain->HaveKey(vchAddress))
return Value::null;
pwalletMain->mapKeyMetadata[vchAddress].nCreateTime = 1;
if (!pwalletMain->AddKey(key))
throw JSONRPCError(RPC_WALLET_ERROR, "Error adding key to wallet");
// whenever a key is imported, we need to scan the whole chain
pwalletMain->nTimeFirstKey = 1; // 0 would be considered 'no value'
pwalletMain->ScanForWalletTransactions(pindexGenesisBlock, true);
pwalletMain->ReacceptWalletTransactions();
}
return Value::null;
}
Value importwallet(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
throw runtime_error(
"importwallet <filename>\n"
"Imports keys from a wallet dump file (see dumpwallet).");
EnsureWalletIsUnlocked();
ifstream file;
file.open(params[0].get_str().c_str());
if (!file.is_open())
throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot open wallet dump file");
int64_t nTimeBegin = pindexBest->nTime;
bool fGood = true;
while (file.good()) {
std::string line;
std::getline(file, line);
if (line.empty() || line[0] == '#')
continue;
std::vector<std::string> vstr;
boost::split(vstr, line, boost::is_any_of(" "));
if (vstr.size() < 2)
continue;
CBitcoinSecret vchSecret;
if (!vchSecret.SetString(vstr[0]))
continue;
bool fCompressed;
CKey key;
CSecret secret = vchSecret.GetSecret(fCompressed);
key.SetSecret(secret, fCompressed);
CKeyID keyid = key.GetPubKey().GetID();
if (pwalletMain->HaveKey(keyid)) {
printf("Skipping import of %s (key already present)\n", CBitcoinAddress(keyid).ToString().c_str());
continue;
}
int64_t nTime = DecodeDumpTime(vstr[1]);
std::string strLabel;
bool fLabel = true;
for (unsigned int nStr = 2; nStr < vstr.size(); nStr++) {
if (boost::algorithm::starts_with(vstr[nStr], "#"))
break;
if (vstr[nStr] == "change=1")
fLabel = false;
if (vstr[nStr] == "reserve=1")
fLabel = false;
if (boost::algorithm::starts_with(vstr[nStr], "label=")) {
strLabel = DecodeDumpString(vstr[nStr].substr(6));
fLabel = true;
}
}
printf("Importing %s...\n", CBitcoinAddress(keyid).ToString().c_str());
if (!pwalletMain->AddKey(key)) {
fGood = false;
continue;
}
pwalletMain->mapKeyMetadata[keyid].nCreateTime = nTime;
if (fLabel)
pwalletMain->SetAddressBookName(keyid, strLabel);
nTimeBegin = std::min(nTimeBegin, nTime);
}
file.close();
CBlockIndex *pindex = pindexBest;
while (pindex && pindex->pprev && pindex->nTime > nTimeBegin - 7200)
pindex = pindex->pprev;
if (!pwalletMain->nTimeFirstKey || nTimeBegin < pwalletMain->nTimeFirstKey)
pwalletMain->nTimeFirstKey = nTimeBegin;
printf("Rescanning last %i blocks\n", pindexBest->nHeight - pindex->nHeight + 1);
pwalletMain->ScanForWalletTransactions(pindex);
pwalletMain->ReacceptWalletTransactions();
pwalletMain->MarkDirty();
if (!fGood)
throw JSONRPCError(RPC_WALLET_ERROR, "Error adding some keys to wallet");
return Value::null;
}
Value dumpprivkey(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
throw runtime_error(
"dumpprivkey <cryptonexaddress>\n"
"Reveals the private key corresponding to <cryptonexaddress>.");
EnsureWalletIsUnlocked();
string strAddress = params[0].get_str();
CBitcoinAddress address;
if (!address.SetString(strAddress))
throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid Cryptonex address");
if (fWalletUnlockStakingOnly)
throw JSONRPCError(RPC_WALLET_UNLOCK_NEEDED, "Wallet is unlocked for staking only.");
CKeyID keyID;
if (!address.GetKeyID(keyID))
throw JSONRPCError(RPC_TYPE_ERROR, "Address does not refer to a key");
CSecret vchSecret;
bool fCompressed;
if (!pwalletMain->GetSecret(keyID, vchSecret, fCompressed))
throw JSONRPCError(RPC_WALLET_ERROR, "Private key for address " + strAddress + " is not known");
return CBitcoinSecret(vchSecret, fCompressed).ToString();
}
Value dumpwallet(const Array& params, bool fHelp)
{
if (fHelp || params.size() != 1)
throw runtime_error(
"dumpwallet <filename>\n"
"Dumps all wallet keys in a human-readable format.");
EnsureWalletIsUnlocked();
ofstream file;
file.open(params[0].get_str().c_str());
if (!file.is_open())
throw JSONRPCError(RPC_INVALID_PARAMETER, "Cannot open wallet dump file");
std::map<CKeyID, int64_t> mapKeyBirth;
std::set<CKeyID> setKeyPool;
pwalletMain->GetKeyBirthTimes(mapKeyBirth);
pwalletMain->GetAllReserveKeys(setKeyPool);
// sort time/key pairs
std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
for (std::map<CKeyID, int64_t>::const_iterator it = mapKeyBirth.begin(); it != mapKeyBirth.end(); it++) {
vKeyBirth.push_back(std::make_pair(it->second, it->first));
}
mapKeyBirth.clear();
std::sort(vKeyBirth.begin(), vKeyBirth.end());
// produce output
file << strprintf("# Wallet dump created by Cryptonex %s (%s)\n", CLIENT_BUILD.c_str(), CLIENT_DATE.c_str());
file << strprintf("# * Created on %s\n", EncodeDumpTime(GetTime()).c_str());
file << strprintf("# * Best block at time of backup was %i (%s),\n", nBestHeight, hashBestChain.ToString().c_str());
file << strprintf("# mined on %s\n", EncodeDumpTime(pindexBest->nTime).c_str());
file << "\n";
for (std::vector<std::pair<int64_t, CKeyID> >::const_iterator it = vKeyBirth.begin(); it != vKeyBirth.end(); it++) {
const CKeyID &keyid = it->second;
std::string strTime = EncodeDumpTime(it->first);
std::string strAddr = CBitcoinAddress(keyid).ToString();
bool IsCompressed;
CKey key;
if (pwalletMain->GetKey(keyid, key)) {
if (pwalletMain->mapAddressBook.count(keyid)) {
CSecret secret = key.GetSecret(IsCompressed);
file << strprintf("%s %s label=%s # addr=%s\n", CBitcoinSecret(secret, IsCompressed).ToString().c_str(), strTime.c_str(), EncodeDumpString(pwalletMain->mapAddressBook[keyid]).c_str(), strAddr.c_str());
} else if (setKeyPool.count(keyid)) {
CSecret secret = key.GetSecret(IsCompressed);
file << strprintf("%s %s reserve=1 # addr=%s\n", CBitcoinSecret(secret, IsCompressed).ToString().c_str(), strTime.c_str(), strAddr.c_str());
} else {
CSecret secret = key.GetSecret(IsCompressed);
file << strprintf("%s %s change=1 # addr=%s\n", CBitcoinSecret(secret, IsCompressed).ToString().c_str(), strTime.c_str(), strAddr.c_str());
}
}
}
file << "\n";
file << "# End of dump\n";
file.close();
return Value::null;
}
|
[
"[email protected]"
] | |
84fc71ca50eb4af796ab84937f61250bc4fefd32
|
e66a50d5ec711c775230719083ed203bf1eb7526
|
/src/main.cpp
|
ff3519a0f57fc587055b49a26d2319e6241dbda9
|
[] |
no_license
|
chetansadhu/Unscented-Kalman-Filter
|
aec486b747865cb955d53820522211eb8e13f249
|
7e98aed6f13befa7154cef05b1aa1401d1f434e8
|
refs/heads/master
| 2020-03-24T19:35:18.148644 | 2018-08-08T01:03:42 | 2018-08-08T01:03:42 | 142,935,212 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 5,263 |
cpp
|
/*
* main.cpp
*
* Created on: Jul 30, 2018
* Author: chetan
*/
#include <uWS/uWS.h>
#include <iostream>
#include "json.hpp"
#include <math.h>
#include "ukf.h"
#include "tools.h"
using namespace std;
// for convenience
using json = nlohmann::json;
// Checks if the SocketIO event has JSON data.
// If there is data the JSON object in string format will be returned,
// else the empty string "" will be returned.
std::string hasData(std::string s) {
auto found_null = s.find("null");
auto b1 = s.find_first_of("[");
auto b2 = s.find_first_of("]");
if (found_null != std::string::npos) {
return "";
}
else if (b1 != std::string::npos && b2 != std::string::npos) {
return s.substr(b1, b2 - b1 + 1);
}
return "";
}
int main()
{
uWS::Hub h;
// Create a Kalman Filter instance
UKF ukf;
// used to compute the RMSE later
Tools tools;
vector<VectorXd> estimations;
vector<VectorXd> ground_truth;
h.onMessage([&ukf,&tools,&estimations,&ground_truth](uWS::WebSocket<uWS::SERVER> ws, char *data, size_t length, uWS::OpCode opCode) {
// "42" at the start of the message means there's a websocket message event.
// The 4 signifies a websocket message
// The 2 signifies a websocket event
if (length && length > 2 && data[0] == '4' && data[1] == '2')
{
auto s = hasData(std::string(data));
if (s != "") {
auto j = json::parse(s);
std::string event = j[0].get<std::string>();
if (event == "telemetry") {
// j[1] is the data JSON object
string sensor_measurment = j[1]["sensor_measurement"];
MeasurementPackage meas_package;
istringstream iss(sensor_measurment);
long long timestamp;
// reads first element from the current line
string sensor_type;
iss >> sensor_type;
if (sensor_type.compare("L") == 0) {
meas_package.sensor_type_ = MeasurementPackage::LASER;
meas_package.raw_measurements_ = VectorXd(2);
float px;
float py;
iss >> px;
iss >> py;
meas_package.raw_measurements_ << px, py;
iss >> timestamp;
meas_package.timestamp_ = timestamp;
} else if (sensor_type.compare("R") == 0) {
meas_package.sensor_type_ = MeasurementPackage::RADAR;
meas_package.raw_measurements_ = VectorXd(3);
float ro;
float theta;
float ro_dot;
iss >> ro;
iss >> theta;
iss >> ro_dot;
meas_package.raw_measurements_ << ro,theta, ro_dot;
iss >> timestamp;
meas_package.timestamp_ = timestamp;
}
float x_gt;
float y_gt;
float vx_gt;
float vy_gt;
iss >> x_gt;
iss >> y_gt;
iss >> vx_gt;
iss >> vy_gt;
VectorXd gt_values(4);
gt_values(0) = x_gt;
gt_values(1) = y_gt;
gt_values(2) = vx_gt;
gt_values(3) = vy_gt;
ground_truth.push_back(gt_values);
//Call ProcessMeasurment(meas_package) for Kalman filter
ukf.ProcessMeasurement(meas_package);
//Push the current estimated x,y positon from the Kalman filter's state vector
VectorXd estimate(4);
double p_x = ukf.x_(0);
double p_y = ukf.x_(1);
double v = ukf.x_(2);
double yaw = ukf.x_(3);
double v1 = cos(yaw)*v;
double v2 = sin(yaw)*v;
estimate(0) = p_x;
estimate(1) = p_y;
estimate(2) = v1;
estimate(3) = v2;
estimations.push_back(estimate);
VectorXd RMSE = tools.CalculateRMSE(estimations, ground_truth);
json msgJson;
msgJson["estimate_x"] = p_x;
msgJson["estimate_y"] = p_y;
msgJson["rmse_x"] = RMSE(0);
msgJson["rmse_y"] = RMSE(1);
msgJson["rmse_vx"] = RMSE(2);
msgJson["rmse_vy"] = RMSE(3);
auto msg = "42[\"estimate_marker\"," + msgJson.dump() + "]";
// std::cout << msg << std::endl;
ws.send(msg.data(), msg.length(), uWS::OpCode::TEXT);
}
} else {
std::string msg = "42[\"manual\",{}]";
ws.send(msg.data(), msg.length(), uWS::OpCode::TEXT);
}
}
});
// We don't need this since we're not using HTTP but if it's removed the program
// doesn't compile :-(
h.onHttpRequest([](uWS::HttpResponse *res, uWS::HttpRequest req, char *data, size_t, size_t) {
const std::string s = "<h1>Hello world!</h1>";
if (req.getUrl().valueLength == 1)
{
res->end(s.data(), s.length());
}
else
{
// i guess this should be done more gracefully?
res->end(nullptr, 0);
}
});
h.onConnection([&h](uWS::WebSocket<uWS::SERVER> ws, uWS::HttpRequest req) {
std::cout << "Connected!!!" << std::endl;
});
h.onDisconnection([&h](uWS::WebSocket<uWS::SERVER> ws, int code, char *message, size_t length) {
ws.close();
std::cout << "Disconnected" << std::endl;
});
int port = 4567;
if (h.listen(port))
{
std::cout << "Listening to port " << port << std::endl;
}
else
{
std::cerr << "Failed to listen to port" << std::endl;
return -1;
}
h.run();
}
|
[
"[email protected]"
] | |
5f801800e7a4968c6315efb32244bbc5daa1b5e0
|
5deff3b693c2cf5fe7b8e3fa2ff3c8599ebed9a7
|
/OpenGLfun/Mesh.cpp
|
e6bcbbf9a0ea8e0c1c5c965eab91ae311c448671
|
[] |
no_license
|
TheMattBauer/OpenGLfun
|
3ef761c9a2d719379c2c0b331da6a6c86a40b0e8
|
0be934c2f6ebed00e604304c060d49d62fa2098c
|
refs/heads/master
| 2021-01-18T15:22:01.002764 | 2015-04-10T06:19:16 | 2015-04-10T06:19:16 | 31,797,000 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,235 |
cpp
|
#include "Mesh.h"
#include <vector>
#include <iostream>
#include <exception>
Mesh::Mesh(const std::string& fileName)
{
Reload(fileName);
}
Mesh::Mesh(Vertex* vertices, unsigned int numVertices, unsigned int* indices, unsigned int numIndices)
{
IndexedModel model;
for(unsigned int i = 0; i < numVertices; i++){
model.positions.push_back(*vertices[i].GetPos());
model.texCoords.push_back(*vertices[i].GetTexCoord());
model.normals.push_back(*vertices[i].GetNormal());
}
for(unsigned int i = 0; i < numIndices; i++){
model.indices.push_back(indices[i]);
}
InitMesh(model);
}
Mesh::~Mesh(void)
{
glDeleteVertexArrays(1, &m_vertexArrayObject);
}
void Mesh::Draw()
{
glBindVertexArray(m_vertexArrayObject);
glDrawElements(GL_TRIANGLES, m_drawCount, GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
}
void Mesh::InitMesh(const IndexedModel& model)
{
m_drawCount = model.indices.size();
glGenVertexArrays(1, &m_vertexArrayObject);
glBindVertexArray(m_vertexArrayObject);
glGenBuffers(NUM_BUFFERS, m_vertexArrayBuffers);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexArrayBuffers[POSITION_VB]);
glBufferData(GL_ARRAY_BUFFER, model.positions.size() * sizeof(model.positions[0]), &model.positions[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexArrayBuffers[TEXCOORD_VB]);
glBufferData(GL_ARRAY_BUFFER, model.positions.size() * sizeof(model.texCoords[0]), &model.texCoords[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexArrayBuffers[NORMAL_VB]);
glBufferData(GL_ARRAY_BUFFER, model.normals.size() * sizeof(model.normals[0]), &model.normals[0], GL_STATIC_DRAW);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_vertexArrayBuffers[INDEX_VB]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, model.indices.size() * sizeof(model.indices[0]), &model.indices[0], GL_STATIC_DRAW);
glBindVertexArray(0);
}
void Mesh::Reload(const std::string& fileName)
{
IndexedModel model = OBJModel(fileName).ToIndexedModel();
InitMesh(model);
}
|
[
"[email protected]"
] | |
330f9fc9a0bf9a78817d36b594ecc378d22dcc05
|
14ce01a6f9199d39e28d036e066d99cfb3e3f211
|
/Cpp/SDK/BP_Base_Sailboat_Green_Empty_functions.cpp
|
c3000fb6665b6bf7548f3b73818dc6cdaa0d757d
|
[] |
no_license
|
zH4x-SDK/zManEater-SDK
|
73f14dd8f758bb7eac649f0c66ce29f9974189b7
|
d040c05a93c0935d8052dd3827c2ef91c128bce7
|
refs/heads/main
| 2023-07-19T04:54:51.672951 | 2021-08-27T13:47:27 | 2021-08-27T13:47:27 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,317 |
cpp
|
// Name: ManEater, Version: 1.0.0
#include "../pch.h"
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Functions
//---------------------------------------------------------------------------
// Function BP_Base_Sailboat_Green_Empty.BP_Base_Sailboat_Green_Empty_C.CanAIAttackTarget
// (Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// struct FAttackTarget PotentialTarget (BlueprintVisible, BlueprintReadOnly, Parm, NoDestructor, ContainsInstancedReference)
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor)
bool ABP_Base_Sailboat_Green_Empty_C::CanAIAttackTarget(const struct FAttackTarget& PotentialTarget)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_Base_Sailboat_Green_Empty.BP_Base_Sailboat_Green_Empty_C.CanAIAttackTarget");
ABP_Base_Sailboat_Green_Empty_C_CanAIAttackTarget_Params params;
params.PotentialTarget = PotentialTarget;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
// Function BP_Base_Sailboat_Green_Empty.BP_Base_Sailboat_Green_Empty_C.GetSizeLevel
// (Event, Public, HasOutParms, BlueprintCallable, BlueprintEvent)
// Parameters:
// class AME_AnimalCharacter* GrabbingAnimal (BlueprintVisible, BlueprintReadOnly, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash)
int ABP_Base_Sailboat_Green_Empty_C::GetSizeLevel(class AME_AnimalCharacter* GrabbingAnimal)
{
static auto fn = UObject::FindObject<UFunction>("Function BP_Base_Sailboat_Green_Empty.BP_Base_Sailboat_Green_Empty_C.GetSizeLevel");
ABP_Base_Sailboat_Green_Empty_C_GetSizeLevel_Params params;
params.GrabbingAnimal = GrabbingAnimal;
auto flags = fn->FunctionFlags;
UObject::ProcessEvent(fn, ¶ms);
fn->FunctionFlags = flags;
return params.ReturnValue;
}
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
[
"[email protected]"
] | |
e3afcc95cfde666468b912eb93228534d3936c2b
|
b688648a5fca3d64b168a5175fab0a96857baede
|
/wzskcmbd/M2msessWzsk.cpp
|
48db421e9408c8094b703a3278d8cc0a69a02ead
|
[
"MIT"
] |
permissive
|
mpsitech/wzsk-Whiznium-StarterKit
|
e4d6f61408d42de86c3055c2156af74eda35c308
|
ce594838ceaaf15a8bd08569f64c15bdcfc3efaa
|
refs/heads/master
| 2022-10-08T23:01:09.686373 | 2022-09-12T20:52:32 | 2022-09-12T20:52:32 | 282,704,920 | 1 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 15,128 |
cpp
|
/**
* \file M2msessWzsk.cpp
* job handler for job M2msessWzsk (implementation)
* \copyright (C) 2016-2020 MPSI Technologies GmbH
* \author Emily Johnson (auto-generation)
* \date created: 5 Dec 2020
*/
// IP header --- ABOVE
#ifdef WZSKCMBD
#include <Wzskcmbd.h>
#else
#include <Wzskd.h>
#endif
#include "M2msessWzsk.h"
#include "M2msessWzsk_blks.cpp"
using namespace std;
using namespace Sbecore;
using namespace Xmlio;
// IP ns.cust --- INSERT
// IP ns.spec --- INSERT
/******************************************************************************
class M2msessWzsk
******************************************************************************/
M2msessWzsk::M2msessWzsk(
XchgWzsk* xchg
, DbsWzsk* dbswzsk
, const ubigint jrefSup
, const ubigint refWzskMUser
, const string& ip
) :
JobWzsk(xchg, VecWzskVJob::M2MSESSWZSK, jrefSup)
{
jref = xchg->addJob(dbswzsk, this, jrefSup);
srcsysinfo = NULL;
iprtrace = NULL;
iprcorner = NULL;
actservo = NULL;
actlaser = NULL;
actexposure = NULL;
acqptcloud = NULL;
acqpreview = NULL;
// IP constructor.cust1 --- INSERT
vector<ubigint> refs;
ubigint refSes;
WzskMUser* usr = NULL;
bool adm;
ListWzskRMUserMUsergroup urus;
uint ixWzskWAccessBase;
// create new session with start time
time_t rawtime;
time(&rawtime);
refSes = dbswzsk->tblwzskmsession->insertNewRec(NULL, refWzskMUser, (uint) rawtime, 0, ip);
xchg->addRefPreset(VecWzskVPreset::PREWZSKSESS, jref, refSes);
xchg->addTxtvalPreset(VecWzskVPreset::PREWZSKIP, jref, ip);
// set locale and presetings corresponding to user
dbswzsk->tblwzskmuser->loadRecByRef(refWzskMUser, &usr);
ixWzskVLocale = usr->ixWzskVLocale;
adm = (usr->ixWzskVUserlevel == VecWzskVUserlevel::ADM);
delete usr;
if (!adm) dbswzsk->tblwzskrmusermusergroup->loadRstByUsr(refWzskMUser, false, urus);
// determine access rights for each feature group and feature
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKSRCSYSINFOVAR, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKSRCSYSINFOVAR, "currCh0VoltCh0", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKSRCSYSINFOVAR, "currCh1VoltCh1", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKSRCSYSINFOVAR, "currCh2VoltCh2", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKSRCSYSINFOVAR, "currCh3VoltCh3", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKSRCSYSINFOVAR, "loadAllLoadCore0LoadCore1LoadCore2LoadCore3", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKSRCSYSINFOVAR, "temp", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEMETHOD, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEMETHOD, "setLevel", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEMETHOD, "setRoi", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEMETHOD, "setRoiNotFull", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEVAR, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEVAR, "pOnLeftPOnRight", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEVAR, "levelOnLevelOff", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEVAR, "roiAxRoiAyRoiBxRoiByRoiCxRoiCyRoiDxRoiDy", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEVAR, "leftRight", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERMETHOD, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERMETHOD, "setNTarget", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERMETHOD, "setRoi", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERMETHOD, "setRoiNotFull", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERVAR, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERVAR, "NTarget", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERVAR, "roiAxRoiAyRoiBxRoiByRoiCxRoiCyRoiDxRoiDy", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERVAR, "flgShiftScoreMinScoreMax", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTSERVOMETHOD, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTSERVOMETHOD, "moveto", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTSERVOMETHOD, "stop", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTSERVOMETHOD, "turn", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTSERVOMETHOD, "zero", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTSERVOVAR, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTSERVOVAR, "angleTarget", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTLASERMETHOD, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTLASERMETHOD, "setLeft", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTLASERMETHOD, "setRight", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTLASERVAR, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTLASERVAR, "leftRight", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTEXPOSUREMETHOD, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTEXPOSUREMETHOD, "setExposure", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTEXPOSUREMETHOD, "setFocus", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTEXPOSUREVAR, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTEXPOSUREVAR, "autoNotManualTexp", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACTEXPOSUREVAR, "focus", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDMETHOD, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDMETHOD, "setDeltaTheta", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDMETHOD, "setDWork", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDVAR, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDVAR, "deltaTheta", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDVAR, "dWork", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDVAR, "xYZ", urus, refWzskMUser, ixWzskWAccessBase);
};
ixWzskWAccessBase = addAccBase(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPREVIEWVAR, adm, urus, refWzskMUser);
if (!adm) {
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPREVIEWVAR, "gray", urus, refWzskMUser, ixWzskWAccessBase);
addAcc(dbswzsk, VecWzskVFeatgroup::VECVJOBWZSKACQPREVIEWVAR, "redGreenBlue", urus, refWzskMUser, ixWzskWAccessBase);
};
// create jobs according to access rights
if (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKSRCSYSINFOVAR, "")) != accs.end()) {
srcsysinfo = new JobWzskSrcSysinfo(xchg, dbswzsk, jref, ixWzskVLocale);
statshr.jrefSrcsysinfo = srcsysinfo->jref;
};
if ( (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEMETHOD, "")) != accs.end()) || (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKIPRTRACEVAR, "")) != accs.end()) ) {
iprtrace = new JobWzskIprTrace(xchg, dbswzsk, jref, ixWzskVLocale);
statshr.jrefIprtrace = iprtrace->jref;
};
if ( (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERMETHOD, "")) != accs.end()) || (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKIPRCORNERVAR, "")) != accs.end()) ) {
iprcorner = new JobWzskIprCorner(xchg, dbswzsk, jref, ixWzskVLocale);
statshr.jrefIprcorner = iprcorner->jref;
};
if ( (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACTSERVOMETHOD, "")) != accs.end()) || (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACTSERVOVAR, "")) != accs.end()) ) {
actservo = new JobWzskActServo(xchg, dbswzsk, jref, ixWzskVLocale);
statshr.jrefActservo = actservo->jref;
};
if ( (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACTLASERMETHOD, "")) != accs.end()) || (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACTLASERVAR, "")) != accs.end()) ) {
actlaser = new JobWzskActLaser(xchg, dbswzsk, jref, ixWzskVLocale);
statshr.jrefActlaser = actlaser->jref;
};
if ( (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACTEXPOSUREMETHOD, "")) != accs.end()) || (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACTEXPOSUREVAR, "")) != accs.end()) ) {
actexposure = new JobWzskActExposure(xchg, dbswzsk, jref, ixWzskVLocale);
statshr.jrefActexposure = actexposure->jref;
};
if ( (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDMETHOD, "")) != accs.end()) || (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACQPTCLOUDVAR, "")) != accs.end()) ) {
acqptcloud = new JobWzskAcqPtcloud(xchg, dbswzsk, jref, ixWzskVLocale);
statshr.jrefAcqptcloud = acqptcloud->jref;
};
if (accs.find(featix_t(VecWzskVFeatgroup::VECVJOBWZSKACQPREVIEWVAR, "")) != accs.end()) {
acqpreview = new JobWzskAcqPreview(xchg, dbswzsk, jref, ixWzskVLocale);
statshr.jrefAcqpreview = acqpreview->jref;
};
// IP constructor.cust2 --- INSERT
// IP constructor.spec2 --- INSERT
xchg->addClstn(VecWzskVCall::CALLWZSKACCESS, jref, Clstn::VecVJobmask::TREE, 0, false, Arg(), 0, Clstn::VecVJactype::LOCK);
// IP constructor.cust3 --- INSERT
// IP constructor.spec3 --- INSERT
};
M2msessWzsk::~M2msessWzsk() {
// IP destructor.spec --- INSERT
// IP destructor.cust --- INSERT
xchg->removeJobByJref(jref);
};
// IP cust --- INSERT
void M2msessWzsk::term(
DbsWzsk* dbswzsk
) {
WzskMSession* ses = NULL;
time_t rawtime;
// update session with stop time
time(&rawtime);
dbswzsk->tblwzskmsession->loadRecByRef(xchg->getRefPreset(VecWzskVPreset::PREWZSKSESS, jref), &ses);
ses->stop = rawtime;
dbswzsk->tblwzskmsession->updateRec(ses);
delete ses;
};
uint M2msessWzsk::addAccBase(
DbsWzsk* dbswzsk
, const uint ixWzskVFeatgroup
, const bool adm
, ListWzskRMUserMUsergroup& urus
, const ubigint refWzskMUser
) {
uint ixWzskWAccess = 0;
getIxAcc(dbswzsk, ixWzskVFeatgroup, "", adm, urus, refWzskMUser, ixWzskWAccess);
if (ixWzskWAccess != 0) accs.insert(pair<featix_t,uint>(featix_t(ixWzskVFeatgroup, ""), ixWzskWAccess));
return ixWzskWAccess;
};
void M2msessWzsk::addAcc(
DbsWzsk* dbswzsk
, const uint ixWzskVFeatgroup
, const string& srefIxVFeature
, ListWzskRMUserMUsergroup& urus
, const ubigint refWzskMUser
, const uint ixWzskWAccessBase
) {
uint ixWzskWAccess = ixWzskWAccessBase;
getIxAcc(dbswzsk, ixWzskVFeatgroup, srefIxVFeature, false, urus, refWzskMUser, ixWzskWAccess);
if (ixWzskWAccess != ixWzskWAccessBase) accs.insert(pair<featix_t,uint>(featix_t(ixWzskVFeatgroup, srefIxVFeature), ixWzskWAccess));
};
void M2msessWzsk::getIxAcc(
DbsWzsk* dbswzsk
, const uint ixWzskVFeatgroup
, const string& srefIxVFeature
, const bool adm
, ListWzskRMUserMUsergroup& urus
, const ubigint refWzskMUser
, uint& ixWzskWAccess
) {
WzskRMUserMUsergroup* uru = NULL;
WzskAMUsergroupAccess* usgAacc = NULL;
WzskAMUserAccess* usrAacc = NULL;
uint ixAcc = 0;
bool first = true;
if (adm) {
ixWzskWAccess = VecWzskWAccess::EDIT + VecWzskWAccess::EXEC + VecWzskWAccess::VIEW;
return;
};
// check for access rights override by any of the applicable user groups
for (unsigned int i = 0; i < urus.nodes.size(); i++) {
uru = urus.nodes[i];
if (dbswzsk->tblwzskamusergroupaccess->loadRecBySQL("SELECT * FROM TblWzskAMUsergroupAccess WHERE refWzskMUsergroup = " + to_string(uru->refWzskMUsergroup) + " AND x1IxWzskVFeatgroup = " + to_string(ixWzskVFeatgroup) + " AND x2FeaSrefUix = '" + srefIxVFeature + "'", &usgAacc)) {
ixAcc |= usgAacc->ixWzskWAccess;
first = false;
delete usgAacc;
};
if (ixAcc == (VecWzskWAccess::EDIT + VecWzskWAccess::EXEC + VecWzskWAccess::VIEW)) break;
};
if (!first) ixWzskWAccess = ixAcc;
// user access rights override user group access rights
if (dbswzsk->tblwzskamuseraccess->loadRecBySQL("SELECT * FROM TblWzskAMUserAccess WHERE refWzskMUser = " + to_string(refWzskMUser) + " AND x1IxWzskVFeatgroup = " + to_string(ixWzskVFeatgroup) + " AND x2FeaSrefUix = '" + srefIxVFeature + "'", &usrAacc)) {
ixWzskWAccess = usrAacc->ixWzskWAccess;
delete usrAacc;
};
};
void M2msessWzsk::handleRequest(
DbsWzsk* dbswzsk
, ReqWzsk* req
) {
if (req->ixVBasetype == ReqWzsk::VecVBasetype::CMD) {
reqCmd = req;
if (req->cmd == "cmdset") {
} else {
cout << "\tinvalid command!" << endl;
};
if (!req->retain) reqCmd = NULL;
} else if (req->ixVBasetype == ReqWzsk::VecVBasetype::DPCHAPP) {
if (req->dpchapp->ixWzskVDpch == VecWzskVDpch::DPCHAPPWZSKINIT) {
handleDpchAppWzskInit(dbswzsk, (DpchAppWzskInit*) (req->dpchapp), &(req->dpcheng));
};
};
};
void M2msessWzsk::handleDpchAppWzskInit(
DbsWzsk* dbswzsk
, DpchAppWzskInit* dpchappwzskinit
, DpchEngWzsk** dpcheng
) {
*dpcheng = new DpchEngData(jref, &statshr, {DpchEngData::ALL});
};
void M2msessWzsk::handleCall(
DbsWzsk* dbswzsk
, Call* call
) {
if (call->ixVCall == VecWzskVCall::CALLWZSKACCESS) {
call->abort = handleCallWzskAccess(dbswzsk, call->jref, call->argInv.ix, call->argInv.sref, call->argRet.ix);
};
};
bool M2msessWzsk::handleCallWzskAccess(
DbsWzsk* dbswzsk
, const ubigint jrefTrig
, const uint ixInv
, const string& srefInv
, uint& ixRet
) {
bool retval = false;
ixRet = 0;
auto it = accs.find(featix_t(ixInv, srefInv));
if (it != accs.end()) ixRet = it->second;
else {
it = accs.find(featix_t(ixInv, ""));
if (it != accs.end()) ixRet = it->second;
};
return retval;
};
|
[
"[email protected]"
] | |
9d8821a480cf39db2aa50a625e90d249a234e2c9
|
03da30d0ea5f65a7658c8a5e86492c96c30907fd
|
/stack/max_rectangle.cpp
|
bf805311578d0850bc924e7e3d0069223a538ca8
|
[] |
no_license
|
ShikhaSahu/Algorithms_And_Coding
|
b7683228cbfe8d03f2fed2b9e426d4915bffe227
|
7e23e914a72c7620b7e09335322b2e1e4b81428c
|
refs/heads/master
| 2020-06-10T01:33:46.252593 | 2019-07-14T08:19:53 | 2019-07-14T08:19:53 | 193,546,297 | 1 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,575 |
cpp
|
/*
Given a binary matrix, Your task is to complete the function maxArea which the maximum size rectangle area in a binary-sub-matrix with all 1’s.
The function takes 3 arguments the first argument is the Matrix M[ ] [ ] and the next two are two integers n and m which denotes the size of
the matrix M. Your function should return an integer denoting the area of the maximum rectangle .
Constraints:
1<=T<=50
1<=n,m<=50
0<=M[][]<=1
Example:
Input
1
4 4
0 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0
Output
8
*/
int histogram(int arr[],int m)
{
stack<int> s;
int i=0,top,maxarea=0,area=0;
while(i<m)
{
if(s.empty() || arr[s.top()]<=arr[i])
s.push(i++);
else
{
top=s.top();
s.pop();
if(s.empty())
area=arr[top]*i;
else
area=arr[top]*(i-1-s.top());
if(area>maxarea)
maxarea=area;
}
}
while(!s.empty())
{
top=s.top();
s.pop();
if(s.empty())
area=arr[top]*i;
else
area=arr[top]*(i-1-s.top());
if(area>maxarea)
maxarea=area;
}
return maxarea;
}
int maxArea(int M[MAX][MAX],int n,int m)
{
//Your code here
//n=rows ,m=cols
int maxarea=histogram(M[0],m);
for(int row=1;row<n;row++)
{
for(int col=0;col<m;col++)
{
if(M[row][col])
M[row][col]+=M[row-1][col];
}
maxarea=max(maxarea,histogram(M[row],m));
}
return maxarea;
}
|
[
"[email protected]"
] | |
763a9d65ecb21b9b292d516947ec253e06377c4b
|
bb6ebff7a7f6140903d37905c350954ff6599091
|
/v8/test/cctest/test-thread-termination.cc
|
b4048ae81906ea8195f8766505b9600f66d47ef9
|
[
"BSD-3-Clause",
"bzip2-1.0.6"
] |
permissive
|
PDi-Communication-Systems-Inc/lollipop_external_chromium_org
|
faa6602bd6bfd9b9b6277ce3cd16df0bd26e7f2f
|
ccadf4e63dd34be157281f53fe213d09a8c66d2c
|
refs/heads/master
| 2022-12-23T18:07:04.568931 | 2016-04-11T16:03:36 | 2016-04-11T16:03:36 | 53,677,925 | 0 | 1 |
BSD-3-Clause
| 2022-12-09T23:46:46 | 2016-03-11T15:49:07 |
C++
|
UTF-8
|
C++
| false | false | 16,805 |
cc
|
// Copyright 2009 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * 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.
// * Neither the name of Google Inc. 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
// OWNER 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.
#include "src/v8.h"
#include "src/platform.h"
#include "test/cctest/cctest.h"
v8::internal::Semaphore* semaphore = NULL;
void Signal(const v8::FunctionCallbackInfo<v8::Value>& args) {
semaphore->Signal();
}
void TerminateCurrentThread(const v8::FunctionCallbackInfo<v8::Value>& args) {
CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
v8::V8::TerminateExecution(args.GetIsolate());
}
void Fail(const v8::FunctionCallbackInfo<v8::Value>& args) {
CHECK(false);
}
void Loop(const v8::FunctionCallbackInfo<v8::Value>& args) {
CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
v8::Handle<v8::String> source = v8::String::NewFromUtf8(
args.GetIsolate(), "try { doloop(); fail(); } catch(e) { fail(); }");
v8::Handle<v8::Value> result = v8::Script::Compile(source)->Run();
CHECK(result.IsEmpty());
CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
}
void DoLoop(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::TryCatch try_catch;
CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
"function f() {"
" var term = true;"
" try {"
" while(true) {"
" if (term) terminate();"
" term = false;"
" }"
" fail();"
" } catch(e) {"
" fail();"
" }"
"}"
"f()"))->Run();
CHECK(try_catch.HasCaught());
CHECK(try_catch.Exception()->IsNull());
CHECK(try_catch.Message().IsEmpty());
CHECK(!try_catch.CanContinue());
CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
}
void DoLoopNoCall(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::TryCatch try_catch;
CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
"var term = true;"
"while(true) {"
" if (term) terminate();"
" term = false;"
"}"))->Run();
CHECK(try_catch.HasCaught());
CHECK(try_catch.Exception()->IsNull());
CHECK(try_catch.Message().IsEmpty());
CHECK(!try_catch.CanContinue());
CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
}
v8::Handle<v8::ObjectTemplate> CreateGlobalTemplate(
v8::Isolate* isolate,
v8::FunctionCallback terminate,
v8::FunctionCallback doloop) {
v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
global->Set(v8::String::NewFromUtf8(isolate, "terminate"),
v8::FunctionTemplate::New(isolate, terminate));
global->Set(v8::String::NewFromUtf8(isolate, "fail"),
v8::FunctionTemplate::New(isolate, Fail));
global->Set(v8::String::NewFromUtf8(isolate, "loop"),
v8::FunctionTemplate::New(isolate, Loop));
global->Set(v8::String::NewFromUtf8(isolate, "doloop"),
v8::FunctionTemplate::New(isolate, doloop));
return global;
}
// Test that a single thread of JavaScript execution can terminate
// itself.
TEST(TerminateOnlyV8ThreadFromThreadItself) {
v8::HandleScope scope(CcTest::isolate());
v8::Handle<v8::ObjectTemplate> global =
CreateGlobalTemplate(CcTest::isolate(), TerminateCurrentThread, DoLoop);
v8::Handle<v8::Context> context =
v8::Context::New(CcTest::isolate(), NULL, global);
v8::Context::Scope context_scope(context);
CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
// Run a loop that will be infinite if thread termination does not work.
v8::Handle<v8::String> source = v8::String::NewFromUtf8(
CcTest::isolate(), "try { loop(); fail(); } catch(e) { fail(); }");
v8::Script::Compile(source)->Run();
// Test that we can run the code again after thread termination.
CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
v8::Script::Compile(source)->Run();
}
// Test that a single thread of JavaScript execution can terminate
// itself in a loop that performs no calls.
TEST(TerminateOnlyV8ThreadFromThreadItselfNoLoop) {
v8::HandleScope scope(CcTest::isolate());
v8::Handle<v8::ObjectTemplate> global = CreateGlobalTemplate(
CcTest::isolate(), TerminateCurrentThread, DoLoopNoCall);
v8::Handle<v8::Context> context =
v8::Context::New(CcTest::isolate(), NULL, global);
v8::Context::Scope context_scope(context);
CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
// Run a loop that will be infinite if thread termination does not work.
v8::Handle<v8::String> source = v8::String::NewFromUtf8(
CcTest::isolate(), "try { loop(); fail(); } catch(e) { fail(); }");
v8::Script::Compile(source)->Run();
CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
// Test that we can run the code again after thread termination.
v8::Script::Compile(source)->Run();
}
class TerminatorThread : public v8::internal::Thread {
public:
explicit TerminatorThread(i::Isolate* isolate)
: Thread("TerminatorThread"),
isolate_(reinterpret_cast<v8::Isolate*>(isolate)) { }
void Run() {
semaphore->Wait();
CHECK(!v8::V8::IsExecutionTerminating(isolate_));
v8::V8::TerminateExecution(isolate_);
}
private:
v8::Isolate* isolate_;
};
// Test that a single thread of JavaScript execution can be terminated
// from the side by another thread.
TEST(TerminateOnlyV8ThreadFromOtherThread) {
semaphore = new v8::internal::Semaphore(0);
TerminatorThread thread(CcTest::i_isolate());
thread.Start();
v8::HandleScope scope(CcTest::isolate());
v8::Handle<v8::ObjectTemplate> global =
CreateGlobalTemplate(CcTest::isolate(), Signal, DoLoop);
v8::Handle<v8::Context> context =
v8::Context::New(CcTest::isolate(), NULL, global);
v8::Context::Scope context_scope(context);
CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
// Run a loop that will be infinite if thread termination does not work.
v8::Handle<v8::String> source = v8::String::NewFromUtf8(
CcTest::isolate(), "try { loop(); fail(); } catch(e) { fail(); }");
v8::Script::Compile(source)->Run();
thread.Join();
delete semaphore;
semaphore = NULL;
}
int call_count = 0;
void TerminateOrReturnObject(const v8::FunctionCallbackInfo<v8::Value>& args) {
if (++call_count == 10) {
CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
v8::V8::TerminateExecution(args.GetIsolate());
return;
}
v8::Local<v8::Object> result = v8::Object::New(args.GetIsolate());
result->Set(v8::String::NewFromUtf8(args.GetIsolate(), "x"),
v8::Integer::New(args.GetIsolate(), 42));
args.GetReturnValue().Set(result);
}
void LoopGetProperty(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::TryCatch try_catch;
CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
v8::Script::Compile(
v8::String::NewFromUtf8(args.GetIsolate(),
"function f() {"
" try {"
" while(true) {"
" terminate_or_return_object().x;"
" }"
" fail();"
" } catch(e) {"
" fail();"
" }"
"}"
"f()"))->Run();
CHECK(try_catch.HasCaught());
CHECK(try_catch.Exception()->IsNull());
CHECK(try_catch.Message().IsEmpty());
CHECK(!try_catch.CanContinue());
CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
}
// Test that we correctly handle termination exceptions if they are
// triggered by the creation of error objects in connection with ICs.
TEST(TerminateLoadICException) {
v8::Isolate* isolate = CcTest::isolate();
v8::HandleScope scope(isolate);
v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
global->Set(
v8::String::NewFromUtf8(isolate, "terminate_or_return_object"),
v8::FunctionTemplate::New(isolate, TerminateOrReturnObject));
global->Set(v8::String::NewFromUtf8(isolate, "fail"),
v8::FunctionTemplate::New(isolate, Fail));
global->Set(v8::String::NewFromUtf8(isolate, "loop"),
v8::FunctionTemplate::New(isolate, LoopGetProperty));
v8::Handle<v8::Context> context =
v8::Context::New(isolate, NULL, global);
v8::Context::Scope context_scope(context);
CHECK(!v8::V8::IsExecutionTerminating(isolate));
// Run a loop that will be infinite if thread termination does not work.
v8::Handle<v8::String> source = v8::String::NewFromUtf8(
isolate, "try { loop(); fail(); } catch(e) { fail(); }");
call_count = 0;
v8::Script::Compile(source)->Run();
// Test that we can run the code again after thread termination.
CHECK(!v8::V8::IsExecutionTerminating(isolate));
call_count = 0;
v8::Script::Compile(source)->Run();
}
void ReenterAfterTermination(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::TryCatch try_catch;
CHECK(!v8::V8::IsExecutionTerminating(args.GetIsolate()));
v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
"function f() {"
" var term = true;"
" try {"
" while(true) {"
" if (term) terminate();"
" term = false;"
" }"
" fail();"
" } catch(e) {"
" fail();"
" }"
"}"
"f()"))->Run();
CHECK(try_catch.HasCaught());
CHECK(try_catch.Exception()->IsNull());
CHECK(try_catch.Message().IsEmpty());
CHECK(!try_catch.CanContinue());
CHECK(v8::V8::IsExecutionTerminating(args.GetIsolate()));
v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
"function f() { fail(); } f()"))
->Run();
}
// Test that reentry into V8 while the termination exception is still pending
// (has not yet unwound the 0-level JS frame) does not crash.
TEST(TerminateAndReenterFromThreadItself) {
v8::Isolate* isolate = CcTest::isolate();
v8::HandleScope scope(isolate);
v8::Handle<v8::ObjectTemplate> global = CreateGlobalTemplate(
isolate, TerminateCurrentThread, ReenterAfterTermination);
v8::Handle<v8::Context> context =
v8::Context::New(isolate, NULL, global);
v8::Context::Scope context_scope(context);
CHECK(!v8::V8::IsExecutionTerminating());
v8::Handle<v8::String> source = v8::String::NewFromUtf8(
isolate, "try { loop(); fail(); } catch(e) { fail(); }");
v8::Script::Compile(source)->Run();
CHECK(!v8::V8::IsExecutionTerminating(isolate));
// Check we can run JS again after termination.
CHECK(v8::Script::Compile(
v8::String::NewFromUtf8(isolate,
"function f() { return true; }"
"f()"))
->Run()
->IsTrue());
}
void DoLoopCancelTerminate(const v8::FunctionCallbackInfo<v8::Value>& args) {
v8::TryCatch try_catch;
CHECK(!v8::V8::IsExecutionTerminating());
v8::Script::Compile(v8::String::NewFromUtf8(args.GetIsolate(),
"var term = true;"
"while(true) {"
" if (term) terminate();"
" term = false;"
"}"
"fail();"))->Run();
CHECK(try_catch.HasCaught());
CHECK(try_catch.Exception()->IsNull());
CHECK(try_catch.Message().IsEmpty());
CHECK(!try_catch.CanContinue());
CHECK(v8::V8::IsExecutionTerminating());
CHECK(try_catch.HasTerminated());
v8::V8::CancelTerminateExecution(CcTest::isolate());
CHECK(!v8::V8::IsExecutionTerminating());
}
// Test that a single thread of JavaScript execution can terminate
// itself and then resume execution.
TEST(TerminateCancelTerminateFromThreadItself) {
v8::Isolate* isolate = CcTest::isolate();
v8::HandleScope scope(isolate);
v8::Handle<v8::ObjectTemplate> global = CreateGlobalTemplate(
isolate, TerminateCurrentThread, DoLoopCancelTerminate);
v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL, global);
v8::Context::Scope context_scope(context);
CHECK(!v8::V8::IsExecutionTerminating(CcTest::isolate()));
v8::Handle<v8::String> source = v8::String::NewFromUtf8(
isolate, "try { doloop(); } catch(e) { fail(); } 'completed';");
// Check that execution completed with correct return value.
CHECK(v8::Script::Compile(source)->Run()->Equals(v8_str("completed")));
}
void MicrotaskShouldNotRun(const v8::FunctionCallbackInfo<v8::Value>& info) {
CHECK(false);
}
void MicrotaskLoopForever(const v8::FunctionCallbackInfo<v8::Value>& info) {
v8::Isolate* isolate = info.GetIsolate();
v8::HandleScope scope(isolate);
// Enqueue another should-not-run task to ensure we clean out the queue
// when we terminate.
isolate->EnqueueMicrotask(v8::Function::New(isolate, MicrotaskShouldNotRun));
CompileRun("terminate(); while (true) { }");
CHECK(v8::V8::IsExecutionTerminating());
}
TEST(TerminateFromOtherThreadWhileMicrotaskRunning) {
semaphore = new v8::internal::Semaphore(0);
TerminatorThread thread(CcTest::i_isolate());
thread.Start();
v8::Isolate* isolate = CcTest::isolate();
isolate->SetAutorunMicrotasks(false);
v8::HandleScope scope(isolate);
v8::Handle<v8::ObjectTemplate> global =
CreateGlobalTemplate(CcTest::isolate(), Signal, DoLoop);
v8::Handle<v8::Context> context =
v8::Context::New(CcTest::isolate(), NULL, global);
v8::Context::Scope context_scope(context);
isolate->EnqueueMicrotask(v8::Function::New(isolate, MicrotaskLoopForever));
// The second task should never be run because we bail out if we're
// terminating.
isolate->EnqueueMicrotask(v8::Function::New(isolate, MicrotaskShouldNotRun));
isolate->RunMicrotasks();
v8::V8::CancelTerminateExecution(isolate);
isolate->RunMicrotasks(); // should not run MicrotaskShouldNotRun
thread.Join();
delete semaphore;
semaphore = NULL;
}
|
[
"[email protected]"
] | |
4d82c19d52696608718d819a9f00930cf13ba817
|
cc410bba79b3d4ac144d8f81d18c2a1965d24a06
|
/Art Institute of Vancouver/Semester_6/VGP332 Artificial Intelligence - OLD/my work/PathfindingTest/WinMain.cpp
|
712079511ce82936ab0250b6198c986b534694c8
|
[] |
no_license
|
Khillasaurus/School
|
6d1ffc96e4c1d9a28f99cc423ce5e0bdea370380
|
d3c8cefef74ff8786bb172cd4c8925d9bb94af5b
|
refs/heads/master
| 2020-03-30T05:53:48.030096 | 2015-08-07T19:47:03 | 2015-08-07T19:47:03 | 38,567,740 | 1 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 561 |
cpp
|
//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include <SGE.h>
using namespace SGE;
//-----------------------------------------------------------------------------
// Class Definitions
//-----------------------------------------------------------------------------
void SGE_Initialize()
{
}
void SGE_Terminate()
{
}
bool SGE_Update(float deltaTime)
{
return Input_IsKeyPressed(Keys::ESCAPE);
}
void SGE_Render()
{
}
//HOMEWORK
|
[
"[email protected]"
] | |
e976571ebe564529a88318a46776a6c357b6f3ec
|
8f920e57281d55a20ccb7e3b3d2d2d9e184703c1
|
/client/UI/final/src/End.cpp
|
e82d6973ebd659fab52e7907b836e3b1ff836ab5
|
[] |
no_license
|
HeyImAGinger/rtype-etienne.miltgen
|
db201fc46a7925330c03c70fd589f3388925023e
|
027edb47d7656c96b008bd89066f0eb78ceced5a
|
refs/heads/main
| 2023-02-22T11:48:10.051632 | 2021-01-26T20:22:15 | 2021-01-26T20:22:15 | 333,175,669 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 745 |
cpp
|
/*
** EPITECH PROJECT, 2020
** RType_2020
** File description:
** End
*/
#include "End.hpp"
End::End()
: AScene(END)
{
std::string dir = __FILE__;
dir = dir.substr(0, dir.find_last_of("\\/"));
sf::Texture *textureBg = new sf::Texture();
if (textureBg->loadFromFile(dir + "/../img_src/end.png") == false) exit(EXIT_FAILURE);
_bg = sf::Sprite(*textureBg);
_bg.setPosition(0, 0);
}
End::~End()
{
}
void End::getEvents(game_t *, sf::RenderWindow *)
{
}
void End::updateGame(game_t *gm, sf::RenderWindow *window)
{
_time = gm->clock.getElapsedTime();
if (_time.asSeconds() > 4.0f)
window->close();
}
void End::drawGame(game_t *, sf::RenderWindow *window)
{
window->clear();
window->draw(_bg);
}
|
[
"[email protected]"
] | |
27edeea9e05902dd0362c06f29ec2713909f7f61
|
3e1ac5a6f5473c93fb9d4174ced2e721a7c1ff4c
|
/build/iOS/Preview/include/FuseJS.UserEvents.h
|
93a3ef34d57f4df2ae813eff8c66b0143845212b
|
[] |
no_license
|
dream-plus/DreamPlus_popup
|
49d42d313e9cf1c9bd5ffa01a42d4b7c2cf0c929
|
76bb86b1f2e36a513effbc4bc055efae78331746
|
refs/heads/master
| 2020-04-28T20:47:24.361319 | 2019-05-13T12:04:14 | 2019-05-13T12:04:14 | 175,556,703 | 0 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,140 |
h
|
// This file was generated based on /usr/local/share/uno/Packages/FuseJS/1.9.0/UserEvents.uno.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Fuse.Scripting.IModuleProvider.h>
#include <Fuse.Scripting.NativeModule.h>
#include <Uno.IDisposable.h>
namespace g{namespace Fuse{namespace Scripting{struct Context;}}}
namespace g{namespace FuseJS{struct UserEvents;}}
namespace g{
namespace FuseJS{
// public sealed class UserEvents :30
// {
::g::Fuse::Scripting::NativeModule_type* UserEvents_typeof();
void UserEvents__ctor_2_fn(UserEvents* __this);
void UserEvents__New2_fn(UserEvents** __retval);
void UserEvents__Raise_fn(::g::Fuse::Scripting::Context* context, uArray* args, uObject** __retval);
struct UserEvents : ::g::Fuse::Scripting::NativeModule
{
static uSStrong<UserEvents*> _instance_;
static uSStrong<UserEvents*>& _instance() { return _instance_; }
static bool _warn_;
static bool& _warn() { return _warn_; }
void ctor_2();
static UserEvents* New2();
static uObject* Raise(::g::Fuse::Scripting::Context* context, uArray* args);
};
// }
}} // ::g::FuseJS
|
[
"[email protected]"
] | |
ab43125149e183d2332d8b849575853c74a8fdc8
|
eb247c77c92f624cbd20f13ffaccf7e449a5393a
|
/Chapter_3/mode.cpp
|
c99e68a4ab03ff1fe63b2493827633c81f36e388
|
[] |
no_license
|
MatKie/ThinkLikeAProgrammer
|
c2b5427b77f76ac73cc842cb4b042da750408ba0
|
4c100537a8c624381729b689c8b0274e5422c3e6
|
refs/heads/master
| 2023-04-01T06:51:56.666934 | 2021-04-05T09:51:57 | 2021-04-05T09:51:57 | 280,886,341 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,324 |
cpp
|
#include <iostream>
int main()
{
// We want to find the mode (most common value) of this array
const int ARRAY_SIZE = 12;
int surveyData[ARRAY_SIZE] = {4, 7, 3, 8, 9, 7, 3, 9, 9, 3, 3, 10};
// We could sort it and then device a counting strategy to count
// how often the value doesn't change when going through the array
// again in a top-of-the-hill fashion. This is double pass and the
// better strategy, I remember because I read the same chapter a
// month ago, is to create an array with ten positions initialised
// to zero. We loop over the original array and take the values
// as index to the second array adding one each time. Then we find
// the maximum to this array.
const int COUNT_ARRAY_SIZE = 10;
int countArray[COUNT_ARRAY_SIZE];
int max = 0;
int max_index = 0;
for (int i = 0; i < COUNT_ARRAY_SIZE; i++)
countArray[i] = 0;
for (int i = 0; i < ARRAY_SIZE; i++)
countArray[surveyData[i] - 1]++;
max = countArray[0];
for (int i = 1; i < COUNT_ARRAY_SIZE; i++)
{
if (countArray[i] > max)
{
max = countArray[i];
// Add one because real languages start arrays at zero ;)
max_index = i + 1;
}
}
std::cout << "Max values is " << max_index;
}
|
[
"[email protected]"
] | |
3948f17ffff8264231c7ab9e404ca6bd8ae99246
|
cd240d349c90f77f46f6cb6e20da09ce1bb8f1b4
|
/src/gun.h
|
c6bc88d3209b443432834b470a81cf507e8425dd
|
[] |
no_license
|
iAppleJack/SimpleBattle
|
c52ef1ffc6254a5ec9d4d92e6feaca6f6199666e
|
b072b10161ef3b26031ee2c9e8e9f0111802042c
|
refs/heads/master
| 2021-01-10T10:13:09.522827 | 2016-04-05T18:26:54 | 2016-04-05T18:26:54 | 54,039,574 | 1 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 442 |
h
|
#ifndef GUN_H
#define GUN_H
#include "oxygine-framework.h"
#include "config.h"
#include "Bullet.h"
using namespace oxygine;
using namespace std;
class Gun : public Actor
{
public:
Gun(vector<spBullet> &bullets);
void _rotate(double angle);
void fire(Vector2 position, double ship_angle, double speed, int team);
private:
spSprite gun;
vector<spBullet> &bullets;
};
typedef intrusive_ptr<Gun> spGun;
#endif // SHIP_H
|
[
"iAppleJack"
] |
iAppleJack
|
331e531974d7e58b55e750574d41ca56824b7db8
|
eab07fff7bf5e6d768160b6e2eccd43b5abc7c8b
|
/contests/atcoder/abc/193/D.cpp
|
ca6b4de69e700e68bcd9193811ecc10a94055a2c
|
[] |
no_license
|
btk15049/com-pro
|
ce04a6f4a6e1903550e982a5bf0e9faf020b9bb8
|
a1585aea56017221eb893c4eb736ed573c5c2e2b
|
refs/heads/master
| 2023-08-16T05:43:25.881208 | 2021-09-26T15:31:07 | 2021-09-26T15:31:07 | 355,559,908 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 27,270 |
cpp
|
// https://atcoder.jp/contests/abc193/tasks/abc193_d
#define CIN_ONLY
#define DECIMAL_DIGITS 10
#define STATIC_MOD 1e9 + 7
#ifdef BTK
/*<head>*/
# include "Template.hpp"
/*</head>*/
#else
/*<body>*/
/* #region auto includes */
/* #region stl */
/*<stl>*/
# include <bits/stdc++.h>
# include <sys/types.h>
# include <unistd.h>
using namespace std;
/*</stl>*/
/* #endregion */
/* #region template/Grid.hpp*/
/**
* @brief グリッドをラップするための関数
* @tparam T std::string や std;:vector を想定
* @tparam U 周りに配置する要素の型
* @param grid 入力、R > 0 でないとバグる
* @param material 周りに配置する要素
* @return std::vector<T> material で 周りを埋めた grid
*/
template <typename T, typename U>
inline std::vector<T> wrapGrid(std::vector<T> grid, U material) {
std::vector<T> wrappedGrid(grid.size() + 2,
T(grid[0].size() + 2, material));
for (std::size_t i = 0; i < grid.size(); i++) {
for (std::size_t j = 0; j < grid[i].size(); j++) {
wrappedGrid[i + 1][j + 1] = grid[i][j];
}
}
return wrappedGrid;
}
/**
* @brief
*
*/
constexpr int dr4[] = {0, 1, 0, -1};
constexpr int dc4[] = {-1, 0, 1, 0};
/* #endregion */
/* #region template/Macro.hpp*/
/**
* @file Macro.hpp
* @author btk
* @brief マクロとか，LLとか
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*
*/
//! LL
using LL = long long;
/**
* @def DEBUG
* @brief デバッグ用のif文 提出時はif(0)で実行されない
*/
/*</head>*/
# ifdef BTK
# define DEBUG if (1)
# else
# ifdef CIN_ONLY
# define FAST_IO
# endif
# define DEBUG if (0)
# endif
/**
* @def ALL(v)
* @brief
* ALLマクロ
*/
# define ALL(v) (v).begin(), (v).end()
/**
* @def REC(ret, ...)
* @brief
* 再帰ラムダをするためのマクロ
*/
# define REC(ret, ...) std::function<ret(__VA_ARGS__)>
/**
* @def VAR_NAME(var)
* @brief 変数名を取得する
*/
# define VAR_NAME(var) # var
/**
* @brief
* rangeで生まれる使わない変数を消す用（警告消し）
*/
template <typename T>
inline T& unused_var(T& v) {
return v;
}
template <typename T>
std::vector<T> nestingVector(std::size_t size) {
return std::vector<T>(size);
}
template <typename T, typename... Ts>
inline auto nestingVector(std::size_t size, Ts... ts) {
return std::vector<decltype(nestingVector<T>(ts...))>(
size, nestingVector<T>(ts...));
}
/* #endregion */
/* #region template/IO.hpp*/
/**
* @file IO.hpp
* @author btk
* @brief cin高速化とか，出力の小数桁固定とか
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*/
/**
* @brief 入出力の設定を行うための構造体
*/
struct cww {
/**
* @brief Construct a new cww::cww object
* @details
* CIN_ONLYを定義すると，submit時にcinとscanfの同期を切る設定が走る
* DECIMAL_DIGITSを定義すると，doubleの出力時指定した桁数分小数部を吐くようになる
*/
cww() {
# ifdef FAST_IO
std::ios::sync_with_stdio(false);
std::cin.tie(0);
# endif
# ifdef DECIMAL_DIGITS
std::cout << std::fixed;
std::cout << std::setprecision(DECIMAL_DIGITS);
# endif
}
};
//! 入出力設定構造体を実体化
cww star;
/**
* @brief
* vectorに直接cin流すためのやつ
* @tparam T
* @param is
* @param v
* @return istream&
*/
template <typename T>
std::istream& operator>>(std::istream& is, std::vector<T>& v) {
for (auto& it : v) is >> it;
return is;
}
/* #endregion */
/* #region template/IncludeSTL.hpp*/
/**
* @file IncludeSTL.hpp
* @author btk
* @brief 標準ライブラリをincludeするだけ
* @version 0.1
* @date 2019-07-21
* @todo 何故か2回includeされる（展開scriptに
* @copyright Copyright (c) 2019
*
*/
/* #endregion */
/* #region template/Loop.hpp*/
/**
* @file Loop.hpp
* @author btk
* @brief rangeとかループ系のクラス
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*
*/
/**
* @brief
* rangeを逆向きに操作したいとき用
* @details
* ループの範囲は[bg,ed)なので注意
* @see range
*/
class reverse_range {
private:
struct I {
int x;
int operator*() { return x - 1; }
bool operator!=(I& lhs) { return x > lhs.x; }
void operator++() { --x; }
};
I i, n;
public:
/**
* @brief Construct a new reverse range object
*
* @param n
*/
reverse_range(int n) : i({0}), n({n}) {}
/**
* @brief Construct a new reverse range object
*
* @param i
* @param n
*/
reverse_range(int i, int n) : i({i}), n({n}) {}
/**
* @brief
* begin iterator
* @return I&
*/
I& begin() { return n; }
/**
* @brief
* end iterator
* @return I&
*/
I& end() { return i; }
};
/**
* @brief
* python みたいな range-based for を実現
* @details
* ループの範囲は[bg,ed)なので注意
* !つけると逆向きにループが回る (reverse_range)
* 空間計算量はO(1)
* 使わない変数ができて警告が出がちなので，unused_varとかを使って警告消しするとよい
*/
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I& lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
/**
* @brief Construct a new range object
*
* @param n
*/
range(int n) : i({0}), n({n}) {}
/**
* @brief Construct a new range object
*
* @param i
* @param n
*/
range(int i, int n) : i({i}), n({n}) {}
/**
* @brief
* begin iterator
* @return I&
*/
I& begin() { return i; }
/**
* @brief
* end iterator
* @return I&
*/
I& end() { return n; }
/**
* @brief
* 逆向きに参照するrange(reverse_rangeを取得できるs)
* @return reverse_range
*/
reverse_range operator!() { return reverse_range(*i, *n); }
};
/* #endregion */
/* #region template/ChainOperation.hpp*/
/**
* @file ChainOperation.hpp
* @author btk
* @brief パラメータパックを利用した演算子結合を実現
*/
/**
* @brief テンプレート再帰の末尾
* @tparam F 二項演算
* @tparam T
* @param v
* @return T
*/
template <typename F, typename T>
inline T chain(T&& v) {
return v;
}
/**
* @brief 複数項における演算の結果を返す
* @tparam F
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename F, typename T, typename... Ts>
inline auto chain(const T head, Ts&&... tail) {
return F::exec(head, chain<F>(tail...));
}
/**
* @brief
* 先頭の値をFで参照する関数に基づいて変更できたらする
* @tparam F
* @tparam T
* @tparam Ts
* @param target
* @param candidates
* @return true
* @return false
*/
template <typename F, typename T, typename... Ts>
inline bool changeTarget(T& target, Ts&&... candidates) {
const T old = target;
target = chain<F>(target, candidates...);
return old != target;
}
/* #endregion */
/* #region template/Math.hpp*/
/**
* @file Math.hpp
* @author btk
* @brief 最大値とか最小値を求める
*/
/**
* @brief gcd, ceil等自作算数用関数を集める。stdと被るので名前空間を区切る
*/
namespace math {
/**
* @brief 拡張ユークリッド互除法
* @details ax + by = gとなるx,yを求める
* @param a 入力
* @param b 入力
* @param x 値引き継ぎ用の変数
* @param y 値引き継ぎ用の変数
* @return int64_t g:aとbの最大公約数
*/
int64_t extgcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
int64_t g = a;
x = 1;
y = 0;
if (b != 0) g = extgcd(b, a % b, y, x), y -= (a / b) * x;
return g;
}
namespace inner {
/**
* @brief 2項のgcdを求める
* @tparam T
*/
template <typename T>
struct GCDFunc {
/**
* @brief 本体
* @param l
* @param r
* @return T
*/
static inline T exec(T l, T r) {
while (r != 0) {
T u = l % r;
l = r;
r = u;
}
return l;
}
};
/**
* @brief 2項のgcdを求める
* @tparam T
*/
template <typename T>
struct LCMFunc {
/**
* @brief 本体
* @param l
* @param r
* @return T
*/
static inline T exec(T l, T r) {
return (l / GCDFunc<T>::exec(l, r)) * r;
}
};
} // namespace inner
/**
* @brief valuesの最大公約数
* @tparam Ts パラメータパック
* @param values gcdを求めたい値の集合（2個以上）
* @return int64 最大公約数
*/
template <typename... Ts>
inline int64_t gcd(Ts&&... values) {
return chain<inner::GCDFunc<int64_t>>(values...);
}
/**
* @brief valuesの最小公倍数
* @tparam Ts パラメータパック
* @param values lcmを求めたい値の集合（2個以上）
* @return int64 最小公倍数
*/
template <typename... Ts>
inline int64_t lcm(Ts&&... values) {
return chain<inner::LCMFunc<int64_t>>(values...);
}
/**
* @brief iterator で指定された集合のlcmを求める
* @tparam ITR iterator
* @param l 開始位置
* @param r 終了位置
* @return int64_t lcm
*/
template <typename ITR>
inline int64_t lcmAll(ITR l, ITR r) {
int64_t ret = 1;
for (auto it = l; it != r; ++it) {
ret = lcm(ret, *it);
}
return ret;
}
/**
* @brief container (配列など) で指定された要素のlcmを求める
* @tparam Container vectorやlist
* @param container コンテナ
* @return int64_t lcm
*/
template <typename Container>
inline int64_t lcmAll(Container container) {
int64_t ret = 1;
for (auto e : container) {
ret = lcm(ret, e);
}
return ret;
}
/**
* @brief iterator で指定された集合のgcdを求める
* @tparam ITR iterator
* @param l 開始位置
* @param r 終了位置
* @return int64_t lcm
*/
template <typename ITR>
inline int64_t gcdAll(ITR l, ITR r) {
int64_t ret = 0;
for (auto it = l; it != r; ++it) {
ret = gcd(ret, *it);
}
return ret;
}
/**
* @brief container (配列など) で指定された要素のgcdを求める
* @tparam Container vectorやlist
* @param container コンテナ
* @return int64_t gcd
*/
template <typename Container>
inline int64_t gcdAll(Container container) {
int64_t ret = 0;
for (auto e : container) {
ret = gcd(ret, e);
}
return ret;
}
/**
* @brief u/dを切り上げした整数を求める
* @todo 負の数への対応
* @tparam T 整数型
* @param u 入力
* @param d 入力
* @return T 切り上げ後の値
*/
template <typename T>
inline T ceil(T u, T d) {
return (u + d - (T)1) / d;
}
} // namespace math
/**
* @brief 2項の最小値求める
* @tparam T
*/
template <typename T>
struct minFunc {
/**
* @brief 本体
* @param l
* @param r
* @return T
*/
static T exec(const T l, const T r) { return l < r ? l : r; }
};
/**
* @brief 2項の最大値求める
*
* @tparam T
*/
template <typename T>
struct maxFunc {
/**
* @brief 本体
*
* @param l
* @param r
* @return T
*/
static T exec(const T l, const T r) { return l > r ? l : r; }
};
/**
* @brief 複数項の最小値
* @see chain
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename T, typename... Ts>
inline T minOf(T head, Ts... tail) {
return chain<minFunc<T>>(head, tail...);
}
/**
* @brief 複数項の最大値
* @see chain
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename T, typename... Ts>
inline T maxOf(T head, Ts... tail) {
return chain<maxFunc<T>>(head, tail...);
}
/**
* @brief change min
* @tparam T 型
* @param target 変更する値
* @param candidates
* @return 更新があればtrue
*/
template <typename T, typename... Ts>
inline bool chmin(T& target, Ts&&... candidates) {
return changeTarget<minFunc<T>>(target, candidates...);
}
/**
* @brief chminのmax版
* @see chmin
* @tparam T 型
* @param target 変更する値
* @param candidates
* @return 更新があればtrue
*/
template <typename T, typename... Ts>
inline bool chmax(T& target, Ts&&... candidates) {
return changeTarget<maxFunc<T>>(target, candidates...);
}
/* #endregion */
/* #region template/Random.hpp*/
/**
* @file Random.hpp
* @author btk
* @brief 乱数生成系
* @version 0.1
* @date 2019-07-13
* @copyright Copyright (c) 2019
*/
//! 乱数のシード値をプロセスIDとして取得
const pid_t pid = getpid();
/**
* @brief XorShift32の実装
*/
class XorShift32 {
private:
//! XorShiftの現在の値
unsigned value;
/**
* @brief XorShift32のアルゴリズムに基づいて value を更新
*/
inline void update() {
value = value ^ (value << 13);
value = value ^ (value >> 17);
value = value ^ (value << 5);
}
/**
* @brief 値を更新し，更新前の値を返却
* @return unsigned 呼び出し時の value を用いる
*/
inline unsigned get() {
unsigned v = value;
update();
return v;
}
public:
/**
* @brief [0, 2^bit) の範囲の乱数値を取り出す
* @tparam デフォルトは31
* @return int
*/
template <int bit = 31>
inline int next_int() {
return (int)(get() >> (32 - bit));
}
/**
* @brief [-2^bit,2^bit)の範囲の乱数値を取り出す
* @tparam デフォルトは31
* @return int
*/
template <int bit = 31>
inline int next_signed() {
unsigned v = get();
return (int)((v >> (31 - bit)) - (1 << (bit)));
}
/**
* @brief next_int呼び出し時の最大値を取得
* @tparam 31
* @return int
*/
template <int bit = 31>
inline int range_max() {
return (int)((1u << bit) - 1);
};
/**
* @brief Construct a new XorShift32 object
* @param seed
* @details 初期シードをvalueとするXorShift32のインスタンスを生成
*/
XorShift32(const unsigned seed) {
value = seed;
update();
}
/**
* @brief Construct a new XorShift 32 object
* @details 初期シードをプロセスIDとするXorShift32のインスタンスを生成
*/
XorShift32() : XorShift32(pid) {}
};
/* #endregion */
/* #region template/STLExtension.hpp*/
/**
* @file STLExtension.hpp
* @brief STL独自拡張
*/
namespace ext {
/**
* @brief std::sortのWrapper関数
* @tparam Container std::vectorやstd::listを想定
* @param container ソートしたいコンテナオブジェクト
* @return Container&
* ソート後のコンテナオブジェクト==引数に渡したオブジェクト
*/
template <typename Container>
inline Container& sort(Container& container) {
sort(std::begin(container), std::end(container));
return container;
}
/**
* @brief std::sortのWrapper関数
* @tparam Container std::vectorやstd::listを想定
* @tparam Comparator 比較関数の型
* @param container ソートしたいコンテナオブジェクト
* @param comparator 比較関数
* @return Container&
* ソート後のコンテナオブジェクト==引数に渡したオブジェクト
*/
template <typename Container, typename Comparator>
inline Container& sort(Container& container, Comparator comparator) {
sort(std::begin(container), std::end(container), comparator);
return container;
}
/**
* @brief std::reverseのWrapper関数
* @tparam Container std::vectorやstd::listを想定
* @param container 反転したいコンテナオブジェクト
* @return Container&
* 反転後のコンテナオブジェクト==引数に渡したオブジェクト
*/
template <typename Container>
inline Container& reverse(Container& container) {
reverse(std::begin(container), std::end(container));
return container;
}
/**
* @brief std::accumulateのvector限定Wrapper関数
* @tparam T 配列の要素の型
* @tparam U 戻り値の型
* @param container 配列
* @param zero 初期値
* @return U 総和
*/
template <typename T, typename U>
inline U accumulate(const std::vector<T>& container, U zero) {
return std::accumulate(std::begin(container), std::end(container),
zero);
}
/**
* @brief std::accumulateのvector限定Wrapper関数の、引数省略版
* @tparam T 配列の要素の型 && 戻り値の型
* @param container 配列
* @return T 総和 overflowに注意
*/
template <typename T>
inline T accumulate(const std::vector<T>& container) {
return accumulate(container, T(0));
}
/**
* @brief std::countのWrapper関数
* @tparam Container std::vectorやstd::listを想定
* @tparam T 数える値の型
* @param container コンテナオブジェクト
* @param value 数える値
* @return int
*/
template <typename Container, typename T>
inline int count(Container& container, T value) {
return std::count(std::begin(container), std::end(container), value);
}
/**
* @brief 等差数列のvectorを作る関数
* @param n 要素数
* @param startFrom 初項
* @param step 公差
* @return std::vector<int> 等差数列
*/
inline std::vector<int> iota(int n, int startFrom = 0, int step = 1) {
std::vector<int> container(n);
int v = startFrom;
for (int i = 0; i < n; i++, v += step) {
container[i] = v;
}
return container;
}
/**
* @brief
* (*max_element) のwrapper、位置は返さない
* @tparam ITR iterator
* @param l iteratorの最初
* @param r iteratorの終了位置
* @param defaultValue 要素がないときのデフォルト値
* @return auto 最大値、型はコンテナ内の型
*/
template <typename ITR>
inline auto maxIn(ITR l, ITR r,
std::remove_reference_t<decltype(*l)> defaultValue = 0) {
if (r == l) {
return defaultValue;
}
return *std::max_element(l, r);
}
/**
* @brief maxIn の vector 限定版
* @tparam T 戻り値の型
* @param containter 最大値求める対象のコンテナ
* @param defaultValue コンテナの要素がない場合の初期値
* @return T 最大値、コンテナ似要素がない場合はdefaultValue
*/
template <typename T>
inline T maxIn(std::vector<T> container, T defaultValue = 0) {
return maxIn(container.begin(), container.end(), defaultValue);
}
/**
* @brief
* (*min_element) のwrapper、位置は返さない
* @tparam ITR iterator
* @param l iteratorの最初
* @param r iteratorの終了位置
* @param defaultValue 要素がないときのデフォルト値
* @return auto 最小値、型はコンテナ内の型
*/
template <typename ITR>
inline auto minIn(ITR l, ITR r,
std::remove_reference_t<decltype(*l)> defaultValue = 0) {
if (r == l) {
return defaultValue;
}
return *std::min_element(l, r);
}
/**
* @brief minIn の vector 限定版
* @tparam T 戻り値の型
* @param containter 最大値求める対象のコンテナ
* @param defaultValue コンテナの要素がない場合の初期値
* @return T 最小値、コンテナ似要素がない場合はdefaultValue
*/
template <typename T>
inline T minIn(std::vector<T> container, T defaultValue = 0) {
return minIn(container.begin(), container.end(), defaultValue);
}
} // namespace ext
/* #endregion */
/* #region template/Strings.hpp*/
/**
* @file Strings.hpp
* @author btk
* @brief 文字列を扱いやすくするライブラリ
*/
/**
* @brief コレクションを文字列に変換する関数
* @tparam T コレクションの型、range-based for に対応している必要あり
* @tparam DelimiterType 区切り文字の型
* @param v コレクション
* @param delimiter 区切り文字
* @return std::string delimiterで結合された文字列
*/
template <typename T, typename DelimiterType>
std::string join(const T& v, const DelimiterType& delimiter) {
std::stringstream ss;
bool isFirst = true;
for (auto& it : v) {
if (!isFirst) {
ss << delimiter;
}
isFirst = false;
ss << it;
}
return ss.str();
}
/**
* @brief コレクションを文字列に変換する関数（イテレータ版）
* @tparam ITR イテレータ型
* @tparam DelimiterType 区切り文字の型
* @param bg 開始
* @param ed 終了
* @param delimiter 区切り文字
* @return std::string delimiterで結合された文字列
*/
template <typename ITR, typename DelimiterType>
std::string join(const ITR bg, const ITR ed, const DelimiterType& delimiter) {
std::stringstream ss;
bool isFirst = true;
for (auto it = bg; it != ed; ++it) {
if (!isFirst) {
ss << delimiter;
}
isFirst = false;
ss << *it;
}
return ss.str();
}
/**
* @brief Strings.hppの内部関数
*/
namespace strings {
/**
* @brief std::size_tをWrapする構造体
* @tparam i 本体
*/
template <std::size_t i>
struct IndexWrapper {};
/**
* @brief tuple用のjoin関数の内部で使われるテンプレート構造体（関数）
* @tparam CurrentIndex 現在のindex
* @tparam LastIndex 最後のindex
* @tparam DelimiterType 区切り文字
* @tparam Ts tupleに使用するパラメータパック
*/
template <typename CurrentIndex, typename LastIndex, typename DelimiterType,
typename... Ts>
struct JoinFunc;
/**
* @brief tuple用join関数の再帰末尾用構造体 .joinが本体
* @tparam i 現在のid = tupleの最後の要素のid
* @tparam DelimiterType 区切り文字
* @tparam Ts tupleに使用するパラメータパック
*/
template <std::size_t i, typename DelimiterType, typename... Ts>
struct JoinFunc<IndexWrapper<i>, IndexWrapper<i>, DelimiterType, Ts...> {
/**
* @brief tuple用join関数の末尾再帰
* @param ss stringstream
* @param values 文字列化したいtuple
* @param delimiter 区切り文字
* @return std::stringstream& 引数で渡したもの
*/
static std::stringstream& join(std::stringstream& ss,
const std::tuple<Ts...>& values,
const DelimiterType& delimiter) {
unused_var(delimiter);
ss << std::get<i>(values);
return ss;
}
};
/**
* @brief tuple用join関数の内部構造体
* @tparam i 現在のid
* @tparam j tupleの最後の要素のid
* @tparam DelimiterType 区切り文字
* @tparam Ts パラメータパック
*/
template <std::size_t i, std::size_t j, typename DelimiterType,
typename... Ts>
struct JoinFunc<IndexWrapper<i>, IndexWrapper<j>, DelimiterType, Ts...> {
/**
* @brief tuple用join関数の本体
* @param ss stringstream
* @param values 文字列化したいtuple
* @param delimiter 区切り文字
* @return std::stringstream& 引数で渡したもの
*/
static std::stringstream& join(std::stringstream& ss,
const std::tuple<Ts...>& values,
const DelimiterType& delimiter) {
ss << std::get<i>(values);
ss << delimiter;
return JoinFunc<IndexWrapper<i + 1>, IndexWrapper<j>, DelimiterType,
Ts...>::join(ss, values, delimiter);
}
};
} // namespace strings
/**
* @brief 複数の値をjoinする関数
* @tparam DelimiterType 区切り文字の型
* @tparam Ts パラメータパック
* @param values 文字列として結合したいタプル
* @param delimiter 区切り文字
* @return std::string 結合後の文字列
*/
template <typename DelimiterType, typename... Ts>
std::string join(const std::tuple<Ts...>& values,
const DelimiterType& delimiter) {
std::stringstream ss;
constexpr std::size_t lastIndex =
std::tuple_size<std::tuple<Ts...>>::value - 1u;
return strings::JoinFunc<strings::IndexWrapper<0>,
strings::IndexWrapper<lastIndex>, DelimiterType,
Ts...>::join(ss, values, delimiter)
.str();
}
/* #endregion */
/* #region Template.hpp*/
/**
* @file Template.hpp
* @brief 競技プログラミング用テンプレート
* @author btk15049
* @date 2019/05/02
*/
/* #endregion */
/* #endregion */
/*</body>*/
#endif
int calc(vector<int> v) {
int ret = 0;
for (int i : range(1, 10)) {
int ten = 1;
for (int i : range(ext::count(v, i))) {
ten *= 10;
}
ret += i * ten;
}
return ret;
}
bool battle(vector<int> s, vector<int> t) { return calc(s) > calc(t); }
int main() {
/* write here */
int K;
cin >> K;
vector<int> s(5), t(5);
string ss, tt;
cin >> ss >> tt;
vector<int> rest(10, K);
for (int i : range(4)) {
s[i] = ss[i] - '0';
t[i] = tt[i] - '0';
rest[s[i]]--;
rest[t[i]]--;
}
double ret = 0;
for (int i : range(1, 10)) {
s.back() = i;
const double p = rest[i] / double(9 * K - 8);
rest[i]--;
for (int j : range(1, 10)) {
t.back() = j;
const double q = rest[j] / double(9 * K - 9);
if (battle(s, t)) {
ret += p * q;
}
}
rest[i]++;
}
cout << ret << endl;
return 0;
}
|
[
"[email protected]"
] | |
68f82c0408c6c376bebed6c8620ca2f3e4c582e0
|
72335f4c1c11da288d488c95e77e57e80a84ed00
|
/Instruction.cpp
|
1582563dc3839a2c15cd328977305985e5972656
|
[] |
no_license
|
antoinepay/comp
|
8f8e732558b125270ea05cb8c45609b995e48f7b
|
c0a02ca6db8d8f7efdd9de258d5598012971f898
|
refs/heads/master
| 2020-04-01T20:25:21.732562 | 2018-10-18T10:00:43 | 2018-10-18T10:00:43 | 153,602,889 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 271 |
cpp
|
/*
* Instruction.cpp
*
* Created on: 20 mars 2017
* Author: Pierre
*/
#include "Instruction.h"
Instruction::Instruction() {
// TODO Auto-generated constructor stub
}
Instruction::~Instruction() {
// TODO Auto-generated destructor stub
}
|
[
"[email protected]"
] | |
ae7847e2dbb1f3db38a9b24cef220c48c6f235a1
|
7c8a9d06a324511b583ed8441c3879dd1ad33bb4
|
/engine/render/NXEngine.h
|
77d0c5459691c96bdcae3705d38e4e43f13e66c6
|
[] |
no_license
|
15831944/NXEngine
|
57f03471da704272cb979f301985796e78eae3b8
|
5729fd996f552a53f39671e7db4f4142fe5ff610
|
refs/heads/master
| 2021-06-17T01:45:59.105473 | 2017-05-04T07:18:21 | 2017-05-04T07:18:21 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 549 |
h
|
/*
* File: NXEngine.h
*
* author: 张雄(zhang xiong, [email protected])
* date: 2017_04_10
* purpose: define engine class
*/
#pragma once
#include "../math/NXVector.h"
namespace NX {
class Engine {
};
struct RenderParameter {
class MVMatrixController *pMVController;
class ProjectController *pProjectController;
class IDirect3DDevice9 *pDXDevice;
class IDirect3D9 *pDirectX;
float4 LightPosition;
float3 AmbientColor;
float3 LightColor;
};
}
|
[
"[email protected]"
] | |
6aebe1814eb8aa67624a7e62e2b7e5593af74f70
|
fb7efe44f4d9f30d623f880d0eb620f3a81f0fbd
|
/components/data_use_measurement/core/data_use_user_data.h
|
b8338a2ef9cda227fa0fe0f821253942d0c1be8c
|
[
"BSD-3-Clause"
] |
permissive
|
wzyy2/chromium-browser
|
2644b0daf58f8b3caee8a6c09a2b448b2dfe059c
|
eb905f00a0f7e141e8d6c89be8fb26192a88c4b7
|
refs/heads/master
| 2022-11-23T20:25:08.120045 | 2018-01-16T06:41:26 | 2018-01-16T06:41:26 | 117,618,467 | 3 | 2 |
BSD-3-Clause
| 2022-11-20T22:03:57 | 2018-01-16T02:09:10 | null |
UTF-8
|
C++
| false | false | 3,918 |
h
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_DATA_USE_MEASUREMENT_CORE_DATA_USE_USER_DATA_H_
#define COMPONENTS_DATA_USE_MEASUREMENT_CORE_DATA_USE_USER_DATA_H_
#include <memory>
#include <string>
#include "base/macros.h"
#include "base/supports_user_data.h"
namespace net {
class URLFetcher;
}
namespace data_use_measurement {
// Used to annotate URLRequests with the service name if the URLRequest is used
// by a service.
class DataUseUserData : public base::SupportsUserData::Data {
public:
// This enum should be synced with DataUseServices enum in histograms.xml.
// Please keep them synced after any updates. Also add service name to
// GetServiceNameAsString function and the same service name to
// DataUse.Service.Types histogram suffixes in histograms.xml
enum ServiceName {
NOT_TAGGED,
SUGGESTIONS,
TRANSLATE,
SYNC,
OMNIBOX,
INVALIDATION,
RAPPOR,
VARIATIONS,
UMA,
DOMAIN_RELIABILITY,
PROFILE_DOWNLOADER,
GOOGLE_URL_TRACKER,
AUTOFILL,
POLICY,
SPELL_CHECKER,
NTP_SNIPPETS_OBSOLETE,
SAFE_BROWSING,
DATA_REDUCTION_PROXY,
PRECACHE,
NTP_TILES,
FEEDBACK_UPLOADER,
TRACING_UPLOADER,
DOM_DISTILLER,
CLOUD_PRINT,
SEARCH_PROVIDER_LOGOS,
UPDATE_CLIENT,
GCM_DRIVER,
WEB_HISTORY_SERVICE,
NETWORK_TIME_TRACKER,
SUPERVISED_USER,
IMAGE_FETCHER_UNTAGGED,
GAIA,
CAPTIVE_PORTAL,
WEB_RESOURCE_SERVICE,
SIGNIN,
NTP_SNIPPETS_SUGGESTIONS,
NTP_SNIPPETS_THUMBNAILS,
DOODLE,
UKM,
PAYMENTS,
LARGE_ICON_SERVICE,
MACHINE_INTELLIGENCE,
};
// Data use broken by content type. This enum must remain synchronized
// with the enum of the same name in metrics/histograms/histograms.xml.
// These values are written to logs. New enum values can be added, but
// existing enums must never be renumbered or deleted and reused.
enum DataUseContentType {
OTHER = 0,
MAIN_FRAME_HTML = 1,
NON_MAIN_FRAME_HTML = 2,
CSS = 3,
IMAGE = 4,
JAVASCRIPT = 5,
FONT = 6,
AUDIO_APPBACKGROUND = 7,
AUDIO_TABBACKGROUND = 8,
AUDIO = 9,
VIDEO_APPBACKGROUND = 10,
VIDEO_TABBACKGROUND = 11,
VIDEO = 12,
TYPE_MAX = 13,
};
// The state of the application. Only available on Android and on other
// platforms it is always FOREGROUND.
enum AppState { UNKNOWN, BACKGROUND, FOREGROUND };
DataUseUserData(ServiceName service_name, AppState app_state);
~DataUseUserData() override;
// Helper function to create DataUseUserData.
static std::unique_ptr<base::SupportsUserData::Data> Create(
DataUseUserData::ServiceName service);
// Return the service name of the ServiceName enum.
static std::string GetServiceNameAsString(ServiceName service);
// Services should use this function to attach their |service_name| to the
// URLFetcher serving them.
static void AttachToFetcher(net::URLFetcher* fetcher,
ServiceName service_name);
ServiceName service_name() const { return service_name_; }
AppState app_state() const { return app_state_; }
void set_app_state(AppState app_state) { app_state_ = app_state; }
DataUseContentType content_type() { return content_type_; }
void set_content_type(DataUseContentType content_type) {
content_type_ = content_type;
}
// The key for retrieving back this type of user data.
static const void* const kUserDataKey;
private:
const ServiceName service_name_;
// App state when network access was performed for the request previously.
AppState app_state_;
DataUseContentType content_type_;
DISALLOW_COPY_AND_ASSIGN(DataUseUserData);
};
} // namespace data_use_measurement
#endif // COMPONENTS_DATA_USE_MEASUREMENT_CORE_DATA_USE_USER_DATA_H_
|
[
"[email protected]"
] | |
e1fcdfec208f43b39276d32d9a1d8f2a052e2d15
|
560090526e32e009e2e9331e8a2b4f1e7861a5e8
|
/Compiled/blaze-3.2/blazemark/blazemark/blitz/DMatDMatSub.h
|
56d09ec01908a3abc6d5ce4abdab3b8a0705332c
|
[
"BSD-3-Clause"
] |
permissive
|
jcd1994/MatlabTools
|
9a4c1f8190b5ceda102201799cc6c483c0a7b6f7
|
2cc7eac920b8c066338b1a0ac495f0dbdb4c75c1
|
refs/heads/master
| 2021-01-18T03:05:19.351404 | 2018-02-14T02:17:07 | 2018-02-14T02:17:07 | 84,264,330 | 2 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 3,028 |
h
|
//=================================================================================================
/*!
// \file blazemark/blitz/DMatDMatSub.h
// \brief Header file for the Blitz++ dense matrix/dense matrix subtraction kernel
//
// Copyright (C) 2012-2017 Klaus Iglberger - All Rights Reserved
//
// This file is part of the Blaze library. You can redistribute it and/or modify it under
// the terms of the New (Revised) BSD License. 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 names of the Blaze development group 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.
*/
//=================================================================================================
#ifndef _BLAZEMARK_BLITZ_DMATDMATSUB_H_
#define _BLAZEMARK_BLITZ_DMATDMATSUB_H_
//*************************************************************************************************
// Includes
//*************************************************************************************************
#include <blazemark/system/Types.h>
namespace blazemark {
namespace blitz {
//=================================================================================================
//
// KERNEL FUNCTIONS
//
//=================================================================================================
//*************************************************************************************************
/*!\name BLitz++ kernel functions */
//@{
double dmatdmatsub( size_t N, size_t steps );
//@}
//*************************************************************************************************
} // namespace blitz
} // namespace blazemark
#endif
|
[
"[email protected]"
] | |
0418ed92cb94dccad6a8d16485cc82fc8451c506
|
0fad34977a5180e29db57495652af995ef484105
|
/j2Console/j2Ams/ParseCalibration.cc
|
77e00467d0541e2e75e227baaa7eba564c53152b
|
[] |
no_license
|
Wenguangliu/Hello
|
5759c237c37ffaf7f9d2cdc18ba6f2895557dda9
|
3801697e51eddb4b03c05924cb5e776ec46e18ae
|
refs/heads/master
| 2020-12-11T20:56:05.865805 | 2020-01-30T22:24:33 | 2020-01-30T22:24:33 | 233,956,105 | 0 | 0 | null | 2020-01-14T23:41:25 | 2020-01-14T23:26:41 | null |
UTF-8
|
C++
| false | false | 11,315 |
cc
|
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <msgqueue.h>
#include <time.h>
#include <errno.h>
#include <expat.h>
#include <ctype.h>
#include "CommonDefines.h"
#include "Crc32.h" // CRC routines from the Common library
#include "Global.h"
#define CALIBRATION_FILE_VERSION 1
// Size of the data buffer into which the config file is read. If the buffer
// is smaller than the size of the file, multiple reads will occur.
#define BUFF_SIZE 8196
static XML_Parser parser_m;
static char paramValue_m[ BUFF_SIZE ];
static char * paramName_m;
static unsigned version_m;
static unsigned receivedCrc_m;
static unsigned calculatedCrc_m;
static bool inData_m;
static bool inParam_m;
static bool inCrc_m;
static bool inVersion_m;
CalibrationData_t * calibrationData_m = 0;
/*
* FUNCTION
* SetParam
*
* DESCRIPTION
* Looks for the given parameter in the list of parameters we're looking for.
* If found, sets the value.
*
* PARAMETERS
* paramName - Name of the parameter found in the XML file.
* value - Associated value of the parameter from the XML file.
*
* RETURNS
* void
*/
static void
SetParam()
{
int i;
char * s;
if ( _stricmp( paramName_m, "barcodeDacs" ) == 0 )
{
s = strtok( paramValue_m, "," );
for ( i = 0; i < NUM_BARCODE_DACS && s != 0; i++ )
{
calibrationData_m->barcodeDacs[ i ] = (unsigned char)strtoul( s, 0, 0 );
s = strtok( 0, "," );
}
}
else if ( _stricmp( paramName_m, "cuvetteMarkDacs" ) == 0 )
{
s = strtok( paramValue_m, "," );
for ( i = 0; i < NUM_CUVETTE_MARK_DACS && s != 0; i++ )
{
calibrationData_m->cuvetteMarkDacs[ i ] = (unsigned char)strtoul( s, 0, 0 );
s = strtok( 0, "," );
}
}
else if ( _stricmp( paramName_m, "wavelengthDacTrims" ) == 0 )
{
s = strtok( paramValue_m, "," );
for ( i = 0; i < NUM_WAVELENGTHS && s != 0; i++ )
{
calibrationData_m->wavelengthDacTrims[ i ] = (unsigned char)strtoul( s, 0, 0 );
s = strtok( 0, "," );
}
}
}
/*
* FUNCTION
* CharacterHandler
*
* DESCRIPTION
* Callback function for the expat parser. This is called whenever there is
* character data between XML tags that we're interested in. We concatenate it
* to the list of characters we might already have read in (this is called more
* than once if the character string spans more than one read from the XML
* file.
*
* PARAMETERS
* userData - Pointer to application-defined user data. We don't use it here.
* s - String of characters the parser has located.
* len - Length of s.
*
* RETURNS
* void
*/
static void
CharacterHandler( void * userData, const XML_Char * s, int len )
{
strncat( paramValue_m, s, len );
}
/*
* FUNCTION
* StartTag
*
* DESCRIPTION
* Callback function for the expat parser. This is called when a start tag is
* located.
*
* PARAMETERS
* data - Pointer to application-defined user data. We don't use it here.
* el - The tag name.
* attr - List of attribute name/value pairs. We don't use them.
*
* RETURNS
* void
*/
static void
StartTag( void *data, const char *el, const char **attr )
{
/*
* If we're in the data section (between the "Record" tags), this is a
* parameter in the file. We save the name and activate the character data
* handler to receive the tag data.
*/
if ( inData_m )
{
paramName_m = _strdup( el );
XML_SetCharacterDataHandler( parser_m, CharacterHandler );
paramValue_m[0] = '\0';
inParam_m = true;
}
/*
* A "Records" tag indicates we've started the section with the parameter
* data.
*/
else if ( _stricmp( el, "Records" ) == 0 )
{
inData_m = true;
}
/*
* A "Version" tag indicates this is the file version. We activate the
* character data handler to receive the version number.
*/
else if ( _stricmp( el, "Version" ) == 0 )
{
XML_SetCharacterDataHandler( parser_m, CharacterHandler );
paramValue_m[0] = '\0';
inVersion_m = true;
}
/*
* A "Signature" tag indicates this is the file signature (CRC). We
* activate the character data handler to receive the CRC.
*/
else if ( _stricmp( el, "Signature" ) == 0 )
{
XML_SetCharacterDataHandler( parser_m, CharacterHandler );
paramValue_m[0] = '\0';
inCrc_m = true;
}
}
/*
* FUNCTION
* EndTag
*
* DESCRIPTION
* Callback function for the expat parser. This is called when an end tag is
* located.
*
* PARAMETERS
* data - Pointer to application-defined user data. We don't use it here.
* el - The tag name.
*
* RETURNS
* void
*/
static void
EndTag( void *data, const char *el )
{
// Turn off the character data handler.
XML_SetCharacterDataHandler( parser_m, 0 );
/*
* We're in the data section (between the "Record" and "/Record" tags), so
* we've either got the end of data for a parameter or the end of the data
* section.
*/
if ( inData_m )
{
// End of data section.
if ( _stricmp( el, "Records" ) == 0 )
{
inData_m = false;
}
// End of data for a parameter.
else if ( inParam_m )
{
// Update the calculated CRC value. (NOTE: Do this before calling
// SetParam(), which may modify paramValue_m.)
calculatedCrc_m = Crc32Update( calculatedCrc_m, (unsigned char *)paramValue_m, strlen( paramValue_m ) );
// Save the value if it's a parameter we're looking for.
SetParam();
// Free the memory we allocated for storing the parameter name and
// signal we're no longer in a parameter.
free( paramName_m );
paramName_m = 0;
inParam_m = false;
}
}
/*
* If we're in the Version, convert the string to a version number and save
* it. Update the CRC.
*/
else if ( inVersion_m )
{
sscanf( paramValue_m, "%u", &version_m );
calculatedCrc_m = Crc32Update( calculatedCrc_m, (unsigned char *)paramValue_m, strlen( paramValue_m ) );
inVersion_m = false;
}
/*
* If we're in the CRC, convert the string to a CRC number and save it.
*/
else if ( inCrc_m )
{
receivedCrc_m = strtoul( paramValue_m, 0, 0 );
inCrc_m = false;
}
}
/*
* FUNCTION
* ParseCalibration
*
* DESCRIPTION
* Parses the given config file, looking for the data fields identified. If
* a given parameter is not found in the file, this will not modify the
* associated data field. No indication will be made if a parameter is not
* found other than that the field has not been modified.
*
* RETURNS
* CFG_ERR_NONE if there are no errors parsing the file, else an error value.
*/
AmsError_t
ParseCalibration (CalibrationData_t * calibrationData )
{
FILE * fp;
int done;
char buff[ BUFF_SIZE ];
/*
* Save the pointer to the calibration data structure we're filling.
*/
calibrationData_m = calibrationData;
/*
* Init the calibration data to default values.
*/
memset( calibrationData, 0, sizeof( CalibrationData_t ) );
/*
* Open the config file.
*/
fp = fopen( CALIBRATION_CONFIG_FILE_NAME, "rb" );
if ( fp == NULL )
{
PrintMsgStatus (OPEN_CALIBRATION_FILE_FAIL);
return OPEN_CALIBRATION_FILE_FAIL;
}
/*
* Create the parser and install the start and end tag callbacks.
*/
parser_m = XML_ParserCreate (NULL);
if ( parser_m == NULL )
{
fclose( fp );
return CREATE_PARSER_FAIL;
}
XML_SetElementHandler( parser_m, StartTag, EndTag );
/*
* Clear flags and init the CRC.
*/
inData_m = false;
inParam_m = false;
inCrc_m = false;
calculatedCrc_m = Crc32Init();
/*
* Repeatedly read from the file and parse what's read. If the buffer is
* at least as large as the file, this will only happen once.
*/
for ( done = 0; !done; )
{
int len;
// Read the file into the buffer.
len = fread( buff, 1, BUFF_SIZE, fp );
if ( ferror( fp ) )
{
fclose( fp );
return XML_READ_ERR;
}
// EOF, so done.
done = feof( fp );
// Parse the buffer.
if ( XML_Parse( parser_m, buff, len, done ) == 0 )
{
fclose( fp );
return XML_SYNTAX_ERR;
}
}
fclose( fp );
// Finalize the CRC calculation and compare it to the CRC read from the file.
calculatedCrc_m = Crc32Finalize( calculatedCrc_m );
if ( calculatedCrc_m != receivedCrc_m )
{
return XML_CRC_ERR;
}
return NO_ERR;
}
/*
* FUNCTION
* WriteCalibration
*
* DESCRIPTION
* Writes the calibration.xml file.
*
* PARAMETERS
* calibrationData - The calibration data to write to the file.
*
* RETURNS
* CFG_ERR_NONE if the write goes OK, else an error indication.
*/
AmsError_t
WriteCalibration (CalibrationData_t * calibrationData)
{
FILE * fp;
unsigned crc = 0;
char dataBuff[ 2000 ];
char * ptr;
int i;
// Open the file.
fp = fopen( CALIBRATION_CONFIG_FILE_NAME, "wb" );
if ( fp == 0 )
{
return OPEN_CALIBRATION_FILE_FAIL;
}
// Initialize the CRC.
crc = Crc32Init();
// Write the file header.
fprintf( fp, "<?xml version='1.0' encoding='UTF-8'?>\n" );
fprintf( fp, "<!-- Calibration Data -->\n" );
fprintf( fp, "<Calibration>\n" );
sprintf( dataBuff, "%u", CALIBRATION_FILE_VERSION );
fprintf( fp, " <Version>%s</Version>\n", dataBuff );
crc = Crc32Update( crc, (unsigned char *)dataBuff, strlen( dataBuff ) );
// Write the parameters.
fprintf( fp, " <Records>\n" );
// barcodeDacs
for ( i = 0, ptr = dataBuff; i < NUM_BARCODE_DACS; i++ )
{
sprintf( ptr, "%u,", calibrationData->barcodeDacs[ i ] );
ptr += strlen( ptr );
}
*--ptr = '\0'; // Remove the last ','
fprintf( fp, " <barcodeDacs>%s</barcodeDacs>\n", dataBuff );
crc = Crc32Update( crc, (unsigned char *)dataBuff, strlen( dataBuff ) );
// cuvetteMarkDacs
for ( i = 0, ptr = dataBuff; i < NUM_CUVETTE_MARK_DACS; i++ )
{
sprintf( ptr, "%u,", calibrationData->cuvetteMarkDacs[ i ] );
ptr += strlen( ptr );
}
*--ptr = '\0'; // Remove the last ','
fprintf( fp, " <cuvetteMarkDacs>%s</cuvetteMarkDacs>\n", dataBuff );
crc = Crc32Update( crc, (unsigned char *)dataBuff, strlen( dataBuff ) );
// wavelengthDacTrims
for ( i = 0, ptr = dataBuff; i < NUM_WAVELENGTHS; i++ )
{
sprintf( ptr, "%u,", calibrationData->wavelengthDacTrims[ i ] );
ptr += strlen( ptr );
}
*--ptr = '\0'; // Remove the last ','
fprintf( fp, " <wavelengthDacTrims>%s</wavelengthDacTrims>\n", dataBuff );
crc = Crc32Update( crc, (unsigned char *)dataBuff, strlen( dataBuff ) );
/*
// wavelengthAdcOffsets
for ( i = 0, ptr = dataBuff; i < NUM_WAVELENGTHS; i++ )
{
sprintf( ptr, "%u,", calibrationData->wavelengthAdcOffsets[ i ] );
ptr += strlen( ptr );
}
*--ptr = '\0'; // Remove the last ','
fprintf( fp, " <wavelengthAdcOffsets>%s</wavelengthAdcOffsets>\n", dataBuff );
crc = Crc32Update( crc, (unsigned char *)dataBuff, strlen( dataBuff ) );
*/
fprintf( fp, " </Records>\n" );
// Write the file signature.
fprintf( fp, " <Signature>%lu</Signature>\n", Crc32Finalize( crc ) );
fprintf( fp, "</Calibration>\n" );
fclose( fp );
return NO_ERR;
}
|
[
"[email protected]"
] | |
a423c86245e873852247fa9453ec0dfd5d491f42
|
182322f4f2800f851754bb1bcb85fd4f9fc324ea
|
/lab/103_2/oop/yyp/hw6/test1.cpp
|
6fff1c9395d586b27bf7bc9ff8d0879dd062219c
|
[] |
no_license
|
Tocknicsu/oj
|
66100fe94d76b6fe8d1bd3019f5ada9d686c1753
|
e84d6c87f3e8c0443a27e8efc749ea4b569a6c91
|
refs/heads/master
| 2021-01-17T08:12:32.510731 | 2016-04-18T02:09:04 | 2016-04-18T02:09:16 | 32,704,322 | 2 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 184 |
cpp
|
#include <cassert>
#include <algorithm>
#include <iostream>
#include <string>
#include "stable_vector.hpp"
using namespace std;
int main() {
stable_vector<int> v1;
return 0;
}
|
[
"[email protected]"
] | |
39ea8b623e731e2fb76934c6eebb518227801e87
|
91f7eaa39276445630cd2ac4b09763b069fbb826
|
/src/Generate_snset.cpp
|
903dcb648ab2ef9f436f5134f9a259d028c2c094
|
[] |
no_license
|
Gaetano03/Clyde-RBM
|
f1c0166d07177b56a6f55ca0d1ff40c584197bef
|
c4d033f39b2f92cf8a4130edf5de1ebbfb8820f1
|
refs/heads/master
| 2021-07-13T10:31:39.392494 | 2019-02-18T18:35:18 | 2019-02-18T18:35:18 | 138,712,470 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 5,015 |
cpp
|
#include "read_Inputs.hpp"
#include "Generate_snset.hpp"
Eigen::MatrixXd generate_snap_matrix( const int Nr, const int Ns, const int ds, const int init,
std::vector<int> Cols,
std::string inputfile,
std::string flag_prob )
{
Eigen::MatrixXd field(Nr, Cols.size());
std::string file_temp;
int k = 0;
std::string root_inputfile;
root_inputfile.assign ( inputfile, 0, inputfile.size() - 4);
std::string input_format;
input_format.assign ( inputfile, inputfile.size() - 3, 3);
if ( flag_prob == "VECTOR-2D")
{
Eigen::MatrixXd snap(2*Nr, Ns);
for( int i = init; i < (Ns*ds + init); i += ds )
{
std::stringstream buffer;
buffer << std::setfill('0') << std::setw(5) << std::to_string(i);
file_temp = root_inputfile + "_" + buffer.str() + "." + input_format;
std::cout << "Reading fields from : " << file_temp << "\t";
field = read_col(file_temp, Nr, Cols);
std::cout << "Complete!" << std::endl;
Eigen::VectorXd gx = field.col(1);
Eigen::VectorXd gy = field.col(2);
snap.col(k) << gx,
gy;
k++;
}
return snap;
} else if ( flag_prob == "VECTOR-3D")
{
Eigen::MatrixXd snap(3*Nr, Ns);
for( int i = init; i < (Ns*ds + init); i += ds )
{
std::stringstream buffer;
buffer << std::setfill('0') << std::setw(5) << std::to_string(i);
file_temp = root_inputfile + "_" + buffer.str() + "." + input_format;
std::cout << "Reading fields from : " << file_temp << "\t";
field = read_col(file_temp, Nr, Cols);
std::cout << "Complete!" << std::endl;
Eigen::VectorXd gx = field.col(1);
Eigen::VectorXd gy = field.col(2);
Eigen::VectorXd gz = field.col(3);
snap.col(k) << gx,
gy,
gz;
k++;
}
return snap;
} else if ( flag_prob == "VELOCITY-2D" )
{
Eigen::MatrixXd snap(2*Nr, Ns);
for( int i = init; i < (Ns*ds + init); i += ds )
{
std::stringstream buffer;
buffer << std::setfill('0') << std::setw(5) << std::to_string(i);
file_temp = root_inputfile + "_" + buffer.str() + "." + input_format;
std::cout << "Reading fields from : " << file_temp << "\t";
field = read_col(file_temp, Nr, Cols);
std::cout << "Complete!" << std::endl;
Eigen::VectorXd rho = field.col(0);
Eigen::VectorXd rho_u = field.col(1);
Eigen::VectorXd rho_v = field.col(2);
Eigen::VectorXd u = rho_u.cwiseQuotient(rho);
Eigen::VectorXd v = rho_v.cwiseQuotient(rho);
snap.col(k) << u,
v;
k++;
}
return snap;
} else if ( flag_prob == "VELOCITY-3D" )
{
Eigen::MatrixXd snap(3*Nr, Ns);
for( int i = init; i < (Ns*ds + init); i += ds )
{
std::stringstream buffer;
buffer << std::setfill('0') << std::setw(5) << std::to_string(i);
file_temp = root_inputfile + "_" + buffer.str() + "." + input_format;
std::cout << "Reading fields from : " << file_temp << "\t";
field = read_col(file_temp, Nr, Cols);
std::cout << "Complete!" << std::endl;
Eigen::VectorXd rho = field.col(0);
Eigen::VectorXd rho_u = field.col(1);
Eigen::VectorXd rho_v = field.col(2);
Eigen::VectorXd rho_w = field.col(3);
Eigen::VectorXd u = rho_u.cwiseQuotient(rho);
Eigen::VectorXd v = rho_v.cwiseQuotient(rho);
Eigen::VectorXd w = rho_w.cwiseQuotient(rho);
snap.col(k) << u,
v,
w;
k++;
}
return snap;
} else if ( flag_prob == "SCALAR" )
{
Eigen::MatrixXd snap(Nr, Ns);
for( int i = init; i < (Ns*ds + init); i += ds )
{
std::stringstream buffer;
buffer << std::setfill('0') << std::setw(5) << std::to_string(i);
file_temp = root_inputfile + "_" + buffer.str() + "." + input_format;
std::cout << "Reading fields from : " << file_temp << "\t";
field = read_col(file_temp, Nr, Cols);
std::cout << "Complete!" << std::endl;
snap.col(k) = field.col(0);
k++;
}
return snap;
} else {
std::cout << "Set well flag_prob! Now Exiting ..." << std::endl;
exit (EXIT_FAILURE);
}
}
|
[
"[email protected]"
] | |
0e1930cf4a7034fe0c6953a6ffc687e5fabe0840
|
8b3b5348b3e07c5fe200149e443c6dc29c82527b
|
/mutex_proc.cpp
|
f689a22c7a0e56401ed066be60cff51f435c9227
|
[] |
no_license
|
LgJianzhao/sync_test
|
49f8674eb2e6bec1b5c7e3ceda0dcfc12903c25b
|
87f63599d58f6c27f3403439b5e2080bc99d8f15
|
refs/heads/master
| 2023-04-08T11:34:15.857887 | 2021-04-21T00:32:25 | 2021-04-21T00:32:25 | 359,642,378 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,505 |
cpp
|
#include <pthread.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include "helper.h"
/* 全局变量 */
int64 targetPerThread = 1000000;
int64 targetShared = 0;
struct mt {
int num;
pthread_mutex_t mutex;
pthread_mutexattr_t mutexattr;
};
int main(int argc, char *argv[]) {
if (argc < 2) {
printf("usage: ./mutex_proc [process size] \n");
return -1;
}
int size = atoi(argv[1]);
// targetPerThread = targetPerThread / size;
struct mt *mm = (mt*) mmap(NULL, sizeof(pthread_mutex_t),
PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
if (&mm->mutex == MAP_FAILED) {
perror("mmap");
return -1;
}
memset(mm, 0x00, sizeof(*mm));
pthread_mutexattr_init(&mm->mutexattr);
pthread_mutexattr_setpshared(&mm->mutexattr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init(&mm->mutex, &mm->mutexattr);
int pid = -1;
for (int i = 0; i < size; ++i) {
pid = fork();
if (pid == -1) {
perror("fork");
break;
}
if (pid == 0) {
if (debug > 2) {
printf("this is child, break");
}
/* 保证创建子进程只在主进程中进行 */
break;
}
}
int64 startTs = STime_GetMicrosecondsTime();
if (pid < 0) {
perror("fork");
return -1;
} else if (pid > 0) { // 父进程
// do nothing
} else { // 子进程
pid_t pid = getpid();
printf("child pid:%d, mutex:%ld \n", pid, mm->mutex);
for (int i = 0; i < targetPerThread; ++i) {
pthread_mutex_lock(&mm->mutex);
mm->num++;
pthread_mutex_unlock(&mm->mutex);
}
// 子进程执行后退出，仅主进程统计性能信息
return 0;
}
// 等待全部子进程结束
while ((pid = waitpid(-1, NULL, 0))) {
if (errno == ECHILD) {
break;
}
}
int64 elapsedTs = STime_GetMicrosecondsTime() - startTs;
long double tps = targetPerThread * size * 1.00 / elapsedTs * 1000 * 1000;
if (debug > 0) {
printf("\n"
"Test Elapsed Time TPS \n"
"count ms. per/s \n");
}
printf("%-10lld %-15lld %-8.2Lf\n", mm->num, elapsedTs / 1000, tps);
pthread_mutexattr_destroy(&mm->mutexattr);
pthread_mutex_destroy(&mm->mutex);
return 0;
}
|
[
"[email protected]"
] | |
efc902c71ef79292956de7a4b13cd82891aa109c
|
2f792be94071bc70418b90b870ed342465dc503e
|
/1365_numbers_less_than_current_no.cpp
|
585052a97caec5f791566158a2caab6aae633b53
|
[] |
no_license
|
Chirag-Jani/DSA
|
56fce8f89ab4122aa5a7a25bf4d728435a991da3
|
9d9592c9ab0708b2662043a109be37b137c3dba3
|
refs/heads/main
| 2023-07-06T01:55:57.473470 | 2021-08-09T17:33:21 | 2021-08-09T17:33:21 | 391,668,782 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,711 |
cpp
|
// Qusestion 1365. How Many Numbers Are Smaller Than the Current Number
// Given the array nums, for each nums[i] find out how many numbers in the array are smaller than it. That is, for each nums[i] you have to count the number of valid j's such that j != i and nums[j] < nums[i].
// Return the answer in an array.
// Example 1:
// Input: nums = [8,1,2,2,3]
// Output: [4,0,1,1,3]
// Explanation:
// For nums[0]=8 there exist four smaller numbers than it (1, 2, 2 and 3).
// For nums[1]=1 does not exist any smaller number than it.
// For nums[2]=2 there exist one smaller number than it (1).
// For nums[3]=2 there exist one smaller number than it (1).
// For nums[4]=3 there exist three smaller numbers than it (1, 2 and 2).
// Example 2:
// Input: nums = [6,5,4,8]
// Output: [2,1,0,3]
// Example 3:
// Input: nums = [7,7,7,7]
// Output: [0,0,0,0]
// Constraints:
// 2 <= nums.length <= 500
// 0 <= nums[i] <= 100
#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
// getting array
int a[n];
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
// Solving
int ansArr[n], noOfElement = 0;
int i = 0;
while (i < n)
{
for (int j = 0; j < n; j++)
{
if (a[i] > a[j])
{
noOfElement++;
ansArr[i] = noOfElement;
}
else
{
ansArr[i] = noOfElement;
}
}
noOfElement = 0;
i++;
}
// printing ans arrray
for (int i = 0; i < n; i++)
{
cout << ansArr[i] << " ";
}
return 0;
}
|
[
"[email protected]"
] | |
edf51d30b3638a2780346b21bfeb3dba75586cd3
|
30bdd8ab897e056f0fb2f9937dcf2f608c1fd06a
|
/Codes/AC/2319.cpp
|
30a2ef0bcee460fcbff1913e3ec040ca0c255c49
|
[] |
no_license
|
thegamer1907/Code_Analysis
|
0a2bb97a9fb5faf01d983c223d9715eb419b7519
|
48079e399321b585efc8a2c6a84c25e2e7a22a61
|
refs/heads/master
| 2020-05-27T01:20:55.921937 | 2019-11-20T11:15:11 | 2019-11-20T11:15:11 | 188,403,594 | 2 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 977 |
cpp
|
#include <bits/stdc++.h>
#define MAXN 10001000
typedef long long ll;
using namespace std;
int n;
int c[MAXN], a[MAXN];
bool marked[MAXN];
int main(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin >> n;
memset(c, 0, MAXN);
memset(a, 0, MAXN);
memset(marked, false, MAXN);
for(int i = 0; i < n; i++){
int t;
cin >> t;
c[t]++;
}
for(int i = 2; i < MAXN; i++){
if(marked[i]) continue;
for(int j = i; j < MAXN; j += i){
marked[j] = true;
a[i] += c[j];
}
}
for(int i = 1; i < MAXN; i++){
//cout << i << " " << a[i] << "\n";
a[i] += a[i - 1];
}
int m;
cin >> m;
for(int i = 0; i < m; i++){
int l, r;
cin >> l >> r;
l = min(l, MAXN - 1);
r = min(r, MAXN - 1);
cout << a[r] - a[l - 1] << "\n";
}
}
|
[
"[email protected]"
] | |
264fb91212a1863c4a1d50fdd7a2f967a9b769ef
|
7cf5491d9c4549135c5d631ec1eb8ac346c0e3f9
|
/bluetoothCommunicator/FoodFeed.ino
|
08ec16fec1e03b996f9b7c54fbda51035b21adbd
|
[
"Apache-2.0"
] |
permissive
|
Shachindra/linkitOne
|
6ceac6d6f15c87cef0e0fca9ff535d59536eab08
|
3779407d7867b16a0a08d6611b7824e6420fa96f
|
refs/heads/master
| 2020-12-26T23:01:06.303180 | 2016-01-14T09:44:55 | 2016-01-14T09:44:55 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 939 |
ino
|
int count=0;
void food_loop(){
if(count%100==0){
digitalWrite(FOODFEEDER,HIGH);
}else if(count%100==5){
digitalWrite(FOODFEEDER,LOW);
}
count++;
}
String commandFoodFeed(JsonObject& root,String commandJson){
int switchAction=root["data"]["switchAction"];
Serial.println(switchAction);
if(switchAction==1){
Serial.println("strip on");
digitalWrite(FOODFEEDER,HIGH);
}else {
Serial.println("strip off");
digitalWrite(FOODFEEDER,LOW);
}
return formResponseFoodFeed();
}
String formResponseFoodFeed()
{
StaticJsonBuffer<300> jsonBuffer;
JsonObject& root = jsonBuffer.createObject();
root["command"] = "foodFeedStatus";
StaticJsonBuffer<300> dataJsonBuffer;
JsonObject& data = root.createNestedObject("data");
data["status"] = true;
root.prettyPrintTo(Serial);
char buffer1[256];
root.printTo(buffer1, sizeof(buffer1));
return String(buffer1);
}
|
[
"[email protected]"
] | |
cbb06674120f81f26daa5b65d96dd61d16536e86
|
9a20a4aaf9c8a4c2bce9b834a583b6f2526d7d43
|
/src/qt/optionsdialog.cpp
|
fa9c58b85ec6ef45e0e400be33539df33e1061a9
|
[
"MIT"
] |
permissive
|
EICoin/EIG
|
6aee34f4088a6ea803e999159fca72204a1e4d31
|
bab4d2248bb7ed37b9749e0ef12beb045487a988
|
refs/heads/master
| 2020-04-29T15:33:27.214164 | 2016-09-19T17:52:05 | 2016-09-19T17:52:05 | 68,561,632 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 8,228 |
cpp
|
#include "optionsdialog.h"
#include "ui_optionsdialog.h"
#include "bitcoinunits.h"
#include "monitoreddatamapper.h"
#include "netbase.h"
#include "optionsmodel.h"
#include <QDir>
#include <QIntValidator>
#include <QLocale>
#include <QMessageBox>
#include <QRegExp>
#include <QRegExpValidator>
OptionsDialog::OptionsDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::OptionsDialog),
model(0),
mapper(0),
fRestartWarningDisplayed_Proxy(false),
fRestartWarningDisplayed_Lang(false),
fProxyIpValid(true)
{
ui->setupUi(this);
/* Network elements init */
#ifndef USE_UPNP
ui->mapPortUpnp->setEnabled(false);
#endif
ui->proxyIp->setEnabled(false);
ui->proxyPort->setEnabled(false);
ui->proxyPort->setValidator(new QIntValidator(1, 65535, this));
ui->socksVersion->setEnabled(false);
ui->socksVersion->addItem("5", 5);
ui->socksVersion->addItem("4", 4);
ui->socksVersion->setCurrentIndex(0);
connect(ui->connectSocks, SIGNAL(toggled(bool)), ui->proxyIp, SLOT(setEnabled(bool)));
connect(ui->connectSocks, SIGNAL(toggled(bool)), ui->proxyPort, SLOT(setEnabled(bool)));
connect(ui->connectSocks, SIGNAL(toggled(bool)), ui->socksVersion, SLOT(setEnabled(bool)));
connect(ui->connectSocks, SIGNAL(clicked(bool)), this, SLOT(showRestartWarning_Proxy()));
ui->proxyIp->installEventFilter(this);
/* Window elements init */
#ifdef Q_OS_MAC
ui->tabWindow->setVisible(false);
#endif
/* Display elements init */
QDir translations(":translations");
ui->lang->addItem(QString("(") + tr("default") + QString(")"), QVariant(""));
foreach(const QString &langStr, translations.entryList())
{
QLocale locale(langStr);
/** check if the locale name consists of 2 parts (language_country) */
if(langStr.contains("_"))
{
#if QT_VERSION >= 0x040800
/** display language strings as "native language - native country (locale name)", e.g. "Deutsch - Deutschland (de)" */
ui->lang->addItem(locale.nativeLanguageName() + QString(" - ") + locale.nativeCountryName() + QString(" (") + langStr + QString(")"), QVariant(langStr));
#else
/** display language strings as "language - country (locale name)", e.g. "German - Germany (de)" */
ui->lang->addItem(QLocale::languageToString(locale.language()) + QString(" - ") + QLocale::countryToString(locale.country()) + QString(" (") + langStr + QString(")"), QVariant(langStr));
#endif
}
else
{
#if QT_VERSION >= 0x040800
/** display language strings as "native language (locale name)", e.g. "Deutsch (de)" */
ui->lang->addItem(locale.nativeLanguageName() + QString(" (") + langStr + QString(")"), QVariant(langStr));
#else
/** display language strings as "language (locale name)", e.g. "German (de)" */
ui->lang->addItem(QLocale::languageToString(locale.language()) + QString(" (") + langStr + QString(")"), QVariant(langStr));
#endif
}
}
ui->unit->setModel(new BitcoinUnits(this));
/* Widget-to-option mapper */
mapper = new MonitoredDataMapper(this);
mapper->setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
mapper->setOrientation(Qt::Vertical);
/* enable apply button when data modified */
connect(mapper, SIGNAL(viewModified()), this, SLOT(enableApplyButton()));
/* disable apply button when new data loaded */
connect(mapper, SIGNAL(currentIndexChanged(int)), this, SLOT(disableApplyButton()));
/* setup/change UI elements when proxy IP is invalid/valid */
connect(this, SIGNAL(proxyIpValid(QValidatedLineEdit *, bool)), this, SLOT(handleProxyIpValid(QValidatedLineEdit *, bool)));
}
OptionsDialog::~OptionsDialog()
{
delete ui;
}
void OptionsDialog::setModel(OptionsModel *model)
{
this->model = model;
if(model)
{
connect(model, SIGNAL(displayUnitChanged(int)), this, SLOT(updateDisplayUnit()));
mapper->setModel(model);
setMapper();
mapper->toFirst();
}
/* update the display unit, to not use the default ("BTC") */
updateDisplayUnit();
/* warn only when language selection changes by user action (placed here so init via mapper doesn't trigger this) */
connect(ui->lang, SIGNAL(valueChanged()), this, SLOT(showRestartWarning_Lang()));
/* disable apply button after settings are loaded as there is nothing to save */
disableApplyButton();
}
void OptionsDialog::setMapper()
{
/* Main */
mapper->addMapping(ui->transactionFee, OptionsModel::Fee);
mapper->addMapping(ui->reserveBalance, OptionsModel::ReserveBalance);
mapper->addMapping(ui->bitcoinAtStartup, OptionsModel::StartAtStartup);
mapper->addMapping(ui->detachDatabases, OptionsModel::DetachDatabases);
/* Network */
mapper->addMapping(ui->mapPortUpnp, OptionsModel::MapPortUPnP);
mapper->addMapping(ui->connectSocks, OptionsModel::ProxyUse);
mapper->addMapping(ui->proxyIp, OptionsModel::ProxyIP);
mapper->addMapping(ui->proxyPort, OptionsModel::ProxyPort);
mapper->addMapping(ui->socksVersion, OptionsModel::ProxySocksVersion);
/* Window */
#ifndef Q_OS_MAC
mapper->addMapping(ui->minimizeToTray, OptionsModel::MinimizeToTray);
mapper->addMapping(ui->minimizeOnClose, OptionsModel::MinimizeOnClose);
#endif
/* Display */
mapper->addMapping(ui->lang, OptionsModel::Language);
mapper->addMapping(ui->unit, OptionsModel::DisplayUnit);
mapper->addMapping(ui->displayAddresses, OptionsModel::DisplayAddresses);
mapper->addMapping(ui->coinControlFeatures, OptionsModel::CoinControlFeatures);
}
void OptionsDialog::enableApplyButton()
{
ui->applyButton->setEnabled(true);
}
void OptionsDialog::disableApplyButton()
{
ui->applyButton->setEnabled(false);
}
void OptionsDialog::enableSaveButtons()
{
/* prevent enabling of the save buttons when data modified, if there is an invalid proxy address present */
if(fProxyIpValid)
setSaveButtonState(true);
}
void OptionsDialog::disableSaveButtons()
{
setSaveButtonState(false);
}
void OptionsDialog::setSaveButtonState(bool fState)
{
ui->applyButton->setEnabled(fState);
ui->okButton->setEnabled(fState);
}
void OptionsDialog::on_okButton_clicked()
{
mapper->submit();
accept();
}
void OptionsDialog::on_cancelButton_clicked()
{
reject();
}
void OptionsDialog::on_applyButton_clicked()
{
mapper->submit();
disableApplyButton();
}
void OptionsDialog::showRestartWarning_Proxy()
{
if(!fRestartWarningDisplayed_Proxy)
{
QMessageBox::warning(this, tr("Warning"), tr("This setting will take effect after restarting EI."), QMessageBox::Ok);
fRestartWarningDisplayed_Proxy = true;
}
}
void OptionsDialog::showRestartWarning_Lang()
{
if(!fRestartWarningDisplayed_Lang)
{
QMessageBox::warning(this, tr("Warning"), tr("This setting will take effect after restarting EI."), QMessageBox::Ok);
fRestartWarningDisplayed_Lang = true;
}
}
void OptionsDialog::updateDisplayUnit()
{
if(model)
{
/* Update transactionFee with the current unit */
ui->transactionFee->setDisplayUnit(model->getDisplayUnit());
}
}
void OptionsDialog::handleProxyIpValid(QValidatedLineEdit *object, bool fState)
{
// this is used in a check before re-enabling the save buttons
fProxyIpValid = fState;
if(fProxyIpValid)
{
enableSaveButtons();
ui->statusLabel->clear();
}
else
{
disableSaveButtons();
object->setValid(fProxyIpValid);
ui->statusLabel->setStyleSheet("QLabel { color: red; }");
ui->statusLabel->setText(tr("The supplied proxy address is invalid."));
}
}
bool OptionsDialog::eventFilter(QObject *object, QEvent *event)
{
if(event->type() == QEvent::FocusOut)
{
if(object == ui->proxyIp)
{
CService addr;
/* Check proxyIp for a valid IPv4/IPv6 address and emit the proxyIpValid signal */
emit proxyIpValid(ui->proxyIp, LookupNumeric(ui->proxyIp->text().toStdString().c_str(), addr));
}
}
return QDialog::eventFilter(object, event);
}
|
[
"[email protected]"
] | |
5abe5abae7a824fdad30fbe442b806d984c5e677
|
612325535126eaddebc230d8c27af095c8e5cc2f
|
/src/base/files/file_path_watcher_stub.cc
|
8a9e03497968dad07d68bad48774f14e55688c95
|
[
"BSD-3-Clause"
] |
permissive
|
TrellixVulnTeam/proto-quic_1V94
|
1a3a03ac7a08a494b3d4e9857b24bb8f2c2cd673
|
feee14d96ee95313f236e0f0e3ff7719246c84f7
|
refs/heads/master
| 2023-04-01T14:36:53.888576 | 2019-10-17T02:23:04 | 2019-10-17T02:23:04 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,042 |
cc
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file exists for Unix systems which don't have the inotify headers, and
// thus cannot build file_watcher_inotify.cc
#include "base/files/file_path_watcher.h"
#include "base/macros.h"
#include "base/memory/ptr_util.h"
namespace base {
namespace {
class FilePathWatcherImpl : public FilePathWatcher::PlatformDelegate {
public:
FilePathWatcherImpl() = default;
~FilePathWatcherImpl() override = default;
bool Watch(const FilePath& path,
bool recursive,
const FilePathWatcher::Callback& callback) override {
return false;
}
void Cancel() override {}
private:
DISALLOW_COPY_AND_ASSIGN(FilePathWatcherImpl);
};
} // namespace
FilePathWatcher::FilePathWatcher() {
sequence_checker_.DetachFromSequence();
impl_ = MakeUnique<FilePathWatcherImpl>();
}
} // namespace base
|
[
"[email protected]"
] | |
622454aafc95403ec3a41e3e7f759403fdde1299
|
88ae8695987ada722184307301e221e1ba3cc2fa
|
/third_party/xnnpack/src/bench/qs8-gemm.cc
|
c91dc835bc71d647db8f3a329e77e9d9410b840a
|
[
"BSD-3-Clause",
"LicenseRef-scancode-generic-cla",
"Apache-2.0",
"LGPL-2.0-or-later",
"MIT",
"GPL-1.0-or-later"
] |
permissive
|
iridium-browser/iridium-browser
|
71d9c5ff76e014e6900b825f67389ab0ccd01329
|
5ee297f53dc7f8e70183031cff62f37b0f19d25f
|
refs/heads/master
| 2023-08-03T16:44:16.844552 | 2023-07-20T15:17:00 | 2023-07-23T16:09:30 | 220,016,632 | 341 | 40 |
BSD-3-Clause
| 2021-08-13T13:54:45 | 2019-11-06T14:32:31 | null |
UTF-8
|
C++
| false | false | 143,584 |
cc
|
// Copyright 2020 Google LLC
//
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree.
#include <algorithm>
#include <cfloat>
#include <chrono>
#include <cmath>
#include <functional>
#include <limits>
#include <mutex>
#include <random>
#include <vector>
#include <benchmark/benchmark.h>
#ifdef BENCHMARK_RUY
#include "ruy/ruy.h"
#endif // BENCHMARK_RUY
#include "bench/gemm.h"
#include "bench/utils.h"
#include <xnnpack/aligned-allocator.h>
#include <xnnpack/common.h>
#include <xnnpack/gemm.h>
#include <xnnpack/math.h>
#include <xnnpack/microfnptr.h>
#include <xnnpack/microparams-init.h>
#include <xnnpack/pack.h>
static void GEMMBenchmark(benchmark::State& state,
xnn_qs8_gemm_minmax_ukernel_fn gemm,
xnn_init_qs8_conv_minmax_params_fn init_params,
size_t mr, size_t nr, size_t kr, size_t sr,
benchmark::utils::IsaCheckFunction isa_check = nullptr,
bool extended_weights = false)
{
if (isa_check != nullptr && !isa_check(state)) {
return;
}
const size_t mc = state.range(0);
const size_t nc = state.range(1);
const size_t kc = state.range(2);
const size_t nc_stride = benchmark::utils::RoundUp(nc, nr);
const size_t kc_stride = benchmark::utils::RoundUp(kc, kr * sr);
std::random_device random_device;
auto rng = std::mt19937(random_device());
auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), std::ref(rng));
auto i8rng = std::bind(
std::uniform_int_distribution<int32_t>(-std::numeric_limits<int8_t>::max(), std::numeric_limits<int8_t>::max()), std::ref(rng));
std::vector<int8_t> a(mc * kc + XNN_EXTRA_BYTES / sizeof(int8_t));
std::generate(a.begin(), a.end(), std::ref(i8rng));
std::vector<int8_t> k(nc * kc);
std::generate(k.begin(), k.end(), std::ref(i8rng));
std::vector<int32_t> b(nc);
std::generate(b.begin(), b.end(), std::ref(i32rng));
const size_t w_element_size = extended_weights ? sizeof(int16_t) : sizeof(int8_t);
const size_t w_size = nc_stride * sizeof(int32_t) + kc_stride * nc_stride * w_element_size;
const size_t c_elements = mc * nc;
const size_t num_buffers = 1 +
benchmark::utils::DivideRoundUp<size_t>(benchmark::utils::GetMaxCacheSize(), w_size + c_elements * sizeof(int8_t));
std::vector<char, AlignedAllocator<char, 64>> w(w_size * num_buffers);
std::fill(w.begin(), w.end(), 0);
const xnn_qs8_packing_params packing_params = { 127 };
if (extended_weights) {
xnn_pack_qs8_gemm_xw_goi_w(1 /* groups */, nc, kc, nr, kr, sr, k.data(), b.data(), w.data(), 0, &packing_params);
} else {
xnn_pack_qs8_gemm_goi_w(1 /* groups */, nc, kc, nr, kr, sr, k.data(), b.data(), w.data(), 0, &packing_params);
}
std::vector<int8_t> c(c_elements * num_buffers);
std::fill(c.begin(), c.end(), 0xA5);
union xnn_qs8_conv_minmax_params quantization_params;
init_params(&quantization_params, 0.75f, 127, -127, 126);
size_t buffer_index = 0;
for (auto _ : state) {
// Use circular buffers (exceeding cache size) and prefetch to control cache state:
// - A is always in L1 cache (if fits, otherwise L2, L3, etc)
// - W is not in cache (for any cache level)
// - C is not in cache (for any cache level)
state.PauseTiming();
benchmark::utils::PrefetchToL1(a.data(), a.size() * sizeof(int8_t));
buffer_index = (buffer_index + 1) % num_buffers;
state.ResumeTiming();
for (uint32_t m = 0; m < mc; m += mr) {
const uint32_t mb = min(mc - m, mr);
for (uint32_t n = 0; n < nc; n += nr) {
const uint32_t nb = min(nc - n, nr);
gemm(
mb, nb, kc * sizeof(int8_t),
a.data() + m * kc, kc * sizeof(int8_t),
w.data() + w_size * buffer_index + n * (kc_stride * w_element_size + sizeof(int32_t)),
c.data() + (mc * buffer_index + m) * nc + n, nc * sizeof(int8_t), nr * sizeof(int8_t),
&quantization_params);
}
}
}
const uint64_t cpu_frequency = benchmark::utils::GetCurrentCpuFrequency();
if (cpu_frequency != 0) {
state.counters["cpufreq"] = cpu_frequency;
}
state.counters["OPS"] = benchmark::Counter(
uint64_t(state.iterations()) * 2 * mc * nc * kc, benchmark::Counter::kIsRate);
}
#ifdef BENCHMARK_RUY
static void RuyBenchmark(benchmark::State& state, size_t threads)
{
const size_t mc = state.range(0);
const size_t nc = state.range(1);
const size_t kc = state.range(2);
std::random_device random_device;
auto rng = std::mt19937(random_device());
auto i32rng = std::bind(std::uniform_int_distribution<int32_t>(-10000, 10000), std::ref(rng));
auto u8rng = std::bind(std::uniform_int_distribution<uint32_t>(0, std::numeric_limits<uint8_t>::max()), std::ref(rng));
const size_t num_buffers = 1 +
benchmark::utils::DivideRoundUp<size_t>(benchmark::utils::GetMaxCacheSize(),
nc * (sizeof(int8_t) * (mc + kc) + sizeof(int32_t)));
std::vector<int8_t> a(mc * kc);
std::generate(a.begin(), a.end(), std::ref(u8rng));
std::vector<int8_t> k(num_buffers * nc * kc);
std::generate(k.begin(), k.end(), std::ref(u8rng));
std::vector<int32_t> b(num_buffers * nc);
std::generate(b.begin(), b.end(), std::ref(i32rng));
std::vector<int8_t> c(num_buffers * nc * mc);
std::fill(c.begin(), c.end(), std::nanf(""));
// Note: context must be static to avoid the cost of re-creating it for each benchmark.
static ruy::Context context;
context.set_max_num_threads(threads);
ruy::Matrix<int8_t> ruy_a;
ruy::MakeSimpleLayout(nc, kc, ruy::Order::kRowMajor, ruy_a.mutable_layout());
ruy_a.set_zero_point(127);
ruy::Matrix<int8_t> ruy_b;
ruy::MakeSimpleLayout(kc, mc, ruy::Order::kColMajor, ruy_b.mutable_layout());
ruy_b.set_data(a.data());
ruy_b.set_zero_point(127);
ruy_b.set_cache_policy(ruy::CachePolicy::kAlwaysCache);
ruy::Matrix<int8_t> ruy_c;
ruy::MakeSimpleLayout(nc, mc, ruy::Order::kColMajor, ruy_c.mutable_layout());
ruy_c.set_zero_point(127);
ruy::MulParams<int32_t, int8_t> mul_params;
mul_params.set_multiplier_fixedpoint(0x40000000);
// ruy::Context uses deferred initialization, which affects percieved GEMM performance. Initialization happens during
// the first GEMM calls, and per Benoit Jacob it takes up to ~250 milliseconds for performance to stabilize.
// Thus, on the first benchmark, we compute GEMM for 500 milliseconds (to be safe) without recording performance, and
// keep the ruy::Context object initialized (by being static) between subsequent benchmarks.
static std::once_flag warmup;
std::call_once(warmup, [&](){
auto start = std::chrono::steady_clock::now();
do {
ruy_a.set_data(k.data());
ruy_c.set_data(c.data());
mul_params.set_bias(b.data());
ruy::Mul(ruy_a, ruy_b, mul_params, &context, &ruy_c);
} while (std::chrono::duration<double>(std::chrono::steady_clock::now() - start).count() < 0.5);
});
size_t buffer_index = 0;
for (auto _ : state) {
// Use circular buffers (exceeding cache size) and prefetch to control cache state:
// - A is always in L1 cache (if fits, otherwise L2, L3, etc)
// - K is not in cache (for any cache level)
// - B is not in cache (for any cache level)
// - C is not in cache (for any cache level)
state.PauseTiming();
benchmark::utils::PrefetchToL1(a.data(), a.size() * sizeof(int8_t));
buffer_index = (buffer_index + 1) % num_buffers;
state.ResumeTiming();
ruy_a.set_data(k.data() + buffer_index * nc * kc);
ruy_c.set_data(c.data() + buffer_index * mc * nc);
mul_params.set_bias(b.data() + buffer_index * nc);
ruy::Mul(ruy_a, ruy_b, mul_params, &context, &ruy_c);
}
const uint64_t cpu_frequency = benchmark::utils::GetCurrentCpuFrequency();
if (cpu_frequency != 0) {
state.counters["cpufreq"] = cpu_frequency;
}
state.counters["OPS"] = benchmark::Counter(
uint64_t(state.iterations()) * 2 * mc * nc * kc, benchmark::Counter::kIsRate);
}
static void ruy_st(benchmark::State& state, const char* net)
{
RuyBenchmark(state, 1);
}
#endif // BENCHMARK_RUY
#if XNN_ARCH_ARM && XNN_PLATFORM_JIT
static void GEMMBenchmark(benchmark::State& state,
xnn_jit_gemm_code_generator_fn generator,
xnn_init_qs8_conv_minmax_params_fn init_params,
size_t mr, size_t nr, size_t kr, size_t sr,
benchmark::utils::IsaCheckFunction isa_check = nullptr)
{
xnn_code_buffer code_buffer;
xnn_allocate_code_memory(&code_buffer, XNN_DEFAULT_CODE_BUFFER_SIZE);
const size_t nc = state.range(1);
const size_t kc = state.range(2);
generator(&code_buffer, mr, nc % nr, kc, nullptr);
xnn_finalize_code_memory(&code_buffer);
GEMMBenchmark(
state,
reinterpret_cast<xnn_qs8_gemm_minmax_ukernel_fn>(code_buffer.start),
init_params,
mr, nr, kr, sr,
isa_check);
xnn_release_code_memory(&code_buffer);
}
static void jit_qs8_gemm_4x8c4__aarch32_neondot_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_generate_qs8_gemm_rndnu_ukernel_4x8c4__aarch32_neondot_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void jit_qs8_gemm_4x8__aarch32_neon_mlal_lane_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_generate_qs8_gemm_rndnu_ukernel_4x8__aarch32_neon_mlal_lane_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void jit_qs8_gemm_4x8__aarch32_neon_mlal_lane_prfm_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_generate_qs8_gemm_rndnu_ukernel_4x8__aarch32_neon_mlal_lane_prfm_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
BENCHMARK_GEMM(jit_qs8_gemm_4x8c4__aarch32_neondot_ld64)
BENCHMARK_GEMM(jit_qs8_gemm_4x8__aarch32_neon_mlal_lane_ld64)
BENCHMARK_GEMM(jit_qs8_gemm_4x8__aarch32_neon_mlal_lane_prfm_ld64)
#endif // XNN_ARCH_ARM && XNN_PLATFORM_JIT
#if XNN_ARCH_ARM && XNN_ENABLE_ASSEMBLY
static void qs8_gemm_4x8c4__asm_aarch32_neondot_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__asm_aarch32_neondot_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_4x8c4__asm_aarch32_neondot_cortex_a55(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__asm_aarch32_neondot_cortex_a55,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_cortex_a53(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__asm_aarch32_neon_mlal_lane_cortex_a53,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a53(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a53,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_cortex_a7(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__asm_aarch32_neon_mlal_lane_cortex_a7,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a7(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a7,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__asm_aarch32_neon_mlal_lane_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_prfm_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__asm_aarch32_neon_mlal_lane_prfm_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8__asm_aarch32_neon_mlal_lane_cortex_a7(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8__asm_aarch32_neon_mlal_lane_cortex_a7,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a7(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a7,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
BENCHMARK_GEMM(qs8_gemm_4x8c4__asm_aarch32_neondot_ld64)
BENCHMARK_GEMM(qs8_gemm_4x8c4__asm_aarch32_neondot_cortex_a55)
BENCHMARK_GEMM(qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_cortex_a53)
BENCHMARK_GEMM(qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a53)
BENCHMARK_GEMM(qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_cortex_a7)
BENCHMARK_GEMM(qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a7)
BENCHMARK_GEMM(qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_ld64)
BENCHMARK_GEMM(qs8_gemm_4x8__asm_aarch32_neon_mlal_lane_prfm_ld64)
BENCHMARK_GEMM(qs8_gemm_1x8__asm_aarch32_neon_mlal_lane_cortex_a7)
BENCHMARK_GEMM(qs8_gemm_1x8__asm_aarch32_neon_mlal_lane_prfm_cortex_a7)
#endif // XNN_ARCH_ARM && XNN_ENABLE_ASSEMBLY
#if XNN_ARCH_ARM64 && XNN_ENABLE_ASSEMBLY
static void qs8_gemm_4x16c4__asm_aarch64_neondot_cortex_a55(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__asm_aarch64_neondot_cortex_a55,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_1x16c4__asm_aarch64_neondot_ld32(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__asm_aarch64_neondot_ld32,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_1x16c4__asm_aarch64_neondot_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__asm_aarch64_neondot_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_4x16c4__asm_aarch64_neondot_ld32(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__asm_aarch64_neondot_ld32,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_4x16c4__asm_aarch64_neondot_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__asm_aarch64_neondot_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_4x16c4__asm_aarch64_neondot_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__asm_aarch64_neondot_ld128,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_4x8__asm_aarch64_neon_mlal_lane_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__asm_aarch64_neon_mlal_lane_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8__asm_aarch64_neon_mlal_lane_prfm_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__asm_aarch64_neon_mlal_lane_prfm_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16__asm_aarch64_neon_mlal_lane_cortex_a53(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16__asm_aarch64_neon_mlal_lane_cortex_a53,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16__asm_aarch64_neon_mlal_lane_prfm_cortex_a53(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16__asm_aarch64_neon_mlal_lane_prfm_cortex_a53,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16__asm_aarch64_neon_mlal_lane_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16__asm_aarch64_neon_mlal_lane_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16__asm_aarch64_neon_mlal_lane_prfm_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16__asm_aarch64_neon_mlal_lane_prfm_ld64,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c8__asm_aarch64_neon_mlal_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c8__asm_aarch64_neon_mlal_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c8__asm_aarch64_neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c8__asm_aarch64_neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c8__asm_aarch64_neon_mlal_cortex_a53(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c8__asm_aarch64_neon_mlal_cortex_a53,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c8__asm_aarch64_neon_mlal_prfm_cortex_a53(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c8__asm_aarch64_neon_mlal_prfm_cortex_a53,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c8__asm_aarch64_neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c8__asm_aarch64_neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c8__asm_aarch64_neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c8__asm_aarch64_neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c8__asm_aarch64_neon_mlal_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c8__asm_aarch64_neon_mlal_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c8__asm_aarch64_neon_mlal_cortex_a53(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c8__asm_aarch64_neon_mlal_cortex_a53,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c8__asm_aarch64_neon_mlal_prfm_cortex_a53(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c8__asm_aarch64_neon_mlal_prfm_cortex_a53,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c16__asm_aarch64_neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c16__asm_aarch64_neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
BENCHMARK_GEMM(qs8_gemm_1x16c4__asm_aarch64_neondot_ld32)
BENCHMARK_GEMM(qs8_gemm_1x16c4__asm_aarch64_neondot_ld64)
BENCHMARK_GEMM(qs8_gemm_4x16c4__asm_aarch64_neondot_ld32)
BENCHMARK_GEMM(qs8_gemm_4x16c4__asm_aarch64_neondot_ld64)
BENCHMARK_GEMM(qs8_gemm_4x16c4__asm_aarch64_neondot_ld128)
BENCHMARK_GEMM(qs8_gemm_4x16c4__asm_aarch64_neondot_cortex_a55)
BENCHMARK_GEMM(qs8_gemm_4x8__asm_aarch64_neon_mlal_lane_ld64)
BENCHMARK_GEMM(qs8_gemm_4x8__asm_aarch64_neon_mlal_lane_prfm_ld64)
BENCHMARK_GEMM(qs8_gemm_4x16__asm_aarch64_neon_mlal_lane_cortex_a53)
BENCHMARK_GEMM(qs8_gemm_4x16__asm_aarch64_neon_mlal_lane_prfm_cortex_a53)
BENCHMARK_GEMM(qs8_gemm_4x16__asm_aarch64_neon_mlal_lane_ld64)
BENCHMARK_GEMM(qs8_gemm_4x16__asm_aarch64_neon_mlal_lane_prfm_ld64)
BENCHMARK_GEMM(qs8_gemm_1x8c8__asm_aarch64_neon_mlal_prfm)
BENCHMARK_GEMM(qs8_gemm_1x8c8__asm_aarch64_neon_mlal)
BENCHMARK_GEMM(qs8_gemm_1x8c8__asm_aarch64_neon_mlal_prfm_cortex_a53)
BENCHMARK_GEMM(qs8_gemm_1x8c8__asm_aarch64_neon_mlal_cortex_a53)
BENCHMARK_GEMM(qs8_gemm_2x8c8__asm_aarch64_neon_mull)
BENCHMARK_GEMM(qs8_gemm_2x8c8__asm_aarch64_neon_mlal)
BENCHMARK_GEMM(qs8_gemm_2x8c8__asm_aarch64_neon_mlal_prfm)
BENCHMARK_GEMM(qs8_gemm_2x8c8__asm_aarch64_neon_mlal_cortex_a53)
BENCHMARK_GEMM(qs8_gemm_2x8c8__asm_aarch64_neon_mlal_prfm_cortex_a53)
BENCHMARK_GEMM(qs8_gemm_2x8c16__asm_aarch64_neon_mlal)
#endif // XNN_ARCH_ARM64 && XNN_ENABLE_ASSEMBLY
#if XNN_ENABLE_ARM_DOTPROD && (XNN_ARCH_ARM || XNN_ARCH_ARM64)
static void qs8_gemm_1x8c4__neondot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c4__neondot,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_4x8c4__neondot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__neondot,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_6x8c4__neondot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_6x8c4__neondot,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/6, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_8x8c4__neondot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_8x8c4__neondot,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/8, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_1x16c4__neondot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__neondot,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_4x16c4__neondot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__neondot,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_6x16c4__neondot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_6x16c4__neondot,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/6, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
static void qs8_gemm_8x16c4__neondot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_8x16c4__neondot,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/8, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEONDOT);
}
BENCHMARK_GEMM(qs8_gemm_1x8c4__neondot)
BENCHMARK_GEMM(qs8_gemm_4x8c4__neondot)
BENCHMARK_GEMM(qs8_gemm_6x8c4__neondot)
BENCHMARK_GEMM(qs8_gemm_8x8c4__neondot)
BENCHMARK_GEMM(qs8_gemm_1x16c4__neondot)
BENCHMARK_GEMM(qs8_gemm_4x16c4__neondot)
BENCHMARK_GEMM(qs8_gemm_6x16c4__neondot)
BENCHMARK_GEMM(qs8_gemm_8x16c4__neondot)
#endif // XNN_ENABLE_ARM_DOTPROD && (XNN_ARCH_ARM || XNN_ARCH_ARM64)
#if XNN_ARCH_ARM || XNN_ARCH_ARM64
static void qs8_gemm_1x8__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_6x8__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_6x8__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/6, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_6x16__neon_mlal_lane(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_6x16__neon_mlal_lane,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/6, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_6x8__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_6x8__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/6, /*nr=*/8, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_6x16__neon_mlal_lane_prfm(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_6x16__neon_mlal_lane_prfm,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/6, /*nr=*/16, /*kr=*/1, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2__neon_mull_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2__neon_mull_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2__neon_mull_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2__neon_mull_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2__neon_mull_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2__neon_mull_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2__neon_mull_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2__neon_mull_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2__neon_mull_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2__neon_mull_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2__neon_mull_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2__neon_mull_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2__neon_mull_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2__neon_mull_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2__neon_mull_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2__neon_mull_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2__neon_mlal_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2__neon_mlal_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2__neon_mlal_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2__neon_mlal_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2__neon_mlal_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2__neon_mlal_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2__neon_mlal_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2__neon_mlal_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2__neon_mlal_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2__neon_mlal_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2__neon_mlal_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2__neon_mlal_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2__neon_mlal_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2__neon_mlal_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2__neon_mlal_ld4r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2__neon_mlal_ld4r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2s4__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2s4__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2s4__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2s4__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2s4__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2s4__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2s4__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2s4__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2s4__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2s4__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2s4__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2s4__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2s4__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2s4__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2s4__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2s4__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c2s4__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c2s4__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c2s4__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c2s4__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c2s4__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c2s4__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c2s4__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c2s4__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c2s4__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c2s4__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c2s4__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c2s4__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c2s4__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c2s4__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c2s4__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c2s4__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c4__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c4__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c4__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c4__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c4__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c4__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c4__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c4__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c4__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c4__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c4__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c4__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c4__neon_mull_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__neon_mull_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c4__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c4__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c4__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c4__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c4__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c4__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c4__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c4__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c4__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c4__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c4__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c4__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c4__neon_mlal_dup(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__neon_mlal_dup,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c4__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c4__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c4__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c4__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c4__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c4__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c4__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c4__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c4__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c4__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c4__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c4__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c4__neon_mull_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__neon_mull_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c4__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c4__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c4__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c4__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c4__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c4__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c4__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c4__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c4__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c4__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c4__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c4__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c4__neon_mlal_ld1r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__neon_mlal_ld1r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c4__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c4__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c4__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c4__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c4__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c4__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c4__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c4__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c4__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c4__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c4__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c4__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c4__neon_mull_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__neon_mull_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c4__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c4__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c4__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c4__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c4__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c4__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c4__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c4__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c4__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c4__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c4__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c4__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c4__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c4__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c4__neon_mlal_ld2r(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c4__neon_mlal_ld2r,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c8__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c8__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c8__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c8__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c8__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c8__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c8__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c8__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c8__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c8__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c8__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c8__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c8__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c8__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c8__neon_mull(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c8__neon_mull,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c8__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c8__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c8__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c8__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c8__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c8__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c8__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c8__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c8__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c8__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c8__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c8__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c8__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c8__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c8__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c8__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x8c16__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x8c16__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/8, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x8c16__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x8c16__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/8, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x8c16__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x8c16__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/8, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x8c16__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x8c16__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/8, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_1x16c16__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_1x16c16__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/1, /*nr=*/16, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_2x16c16__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_2x16c16__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/2, /*nr=*/16, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_3x16c16__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_3x16c16__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/3, /*nr=*/16, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
static void qs8_gemm_4x16c16__neon_mlal(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_rndnu_ukernel_4x16c16__neon_mlal,
xnn_init_qs8_conv_minmax_rndnu_neon_params,
/*mr=*/4, /*nr=*/16, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckNEON);
}
BENCHMARK_GEMM(qs8_gemm_1x8c4__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_2x8c4__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_3x8c4__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_4x8c4__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_1x16c4__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_2x16c4__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_3x16c4__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_4x16c4__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_1x8c4__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_2x8c4__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_3x8c4__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_4x8c4__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_1x16c4__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_2x16c4__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_3x16c4__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_4x16c4__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_1x8c4__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_2x8c4__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_3x8c4__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_4x8c4__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_1x16c4__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_2x16c4__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_3x16c4__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_4x16c4__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_1x8c4__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_2x8c4__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_3x8c4__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_4x8c4__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_1x16c4__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_2x16c4__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_3x16c4__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_4x16c4__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_1x8c4__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_2x8c4__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_3x8c4__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_4x8c4__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_1x16c4__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_2x16c4__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_3x16c4__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_4x16c4__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_1x8c4__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_2x8c4__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_3x8c4__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_4x8c4__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_1x16c4__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_2x16c4__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_3x16c4__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_4x16c4__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_1x8c2__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_2x8c2__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_3x8c2__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_4x8c2__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_1x16c2__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_2x16c2__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_3x16c2__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_4x16c2__neon_mull_dup)
BENCHMARK_GEMM(qs8_gemm_1x8c2__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_2x8c2__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_3x8c2__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_4x8c2__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_1x16c2__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_2x16c2__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_3x16c2__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_4x16c2__neon_mlal_dup)
BENCHMARK_GEMM(qs8_gemm_1x8c2__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_2x8c2__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_3x8c2__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_4x8c2__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_1x16c2__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_2x16c2__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_3x16c2__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_4x16c2__neon_mull_ld1r)
BENCHMARK_GEMM(qs8_gemm_1x8c2__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_2x8c2__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_3x8c2__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_4x8c2__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_1x16c2__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_2x16c2__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_3x16c2__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_4x16c2__neon_mlal_ld1r)
BENCHMARK_GEMM(qs8_gemm_1x8c2__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_2x8c2__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_3x8c2__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_4x8c2__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_1x16c2__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_2x16c2__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_3x16c2__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_4x16c2__neon_mull_ld2r)
BENCHMARK_GEMM(qs8_gemm_1x8c2__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_2x8c2__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_3x8c2__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_4x8c2__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_1x16c2__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_2x16c2__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_3x16c2__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_4x16c2__neon_mlal_ld2r)
BENCHMARK_GEMM(qs8_gemm_1x8c2__neon_mull_ld4r)
BENCHMARK_GEMM(qs8_gemm_2x8c2__neon_mull_ld4r)
BENCHMARK_GEMM(qs8_gemm_3x8c2__neon_mull_ld4r)
BENCHMARK_GEMM(qs8_gemm_4x8c2__neon_mull_ld4r)
BENCHMARK_GEMM(qs8_gemm_1x16c2__neon_mull_ld4r)
BENCHMARK_GEMM(qs8_gemm_2x16c2__neon_mull_ld4r)
BENCHMARK_GEMM(qs8_gemm_3x16c2__neon_mull_ld4r)
BENCHMARK_GEMM(qs8_gemm_4x16c2__neon_mull_ld4r)
BENCHMARK_GEMM(qs8_gemm_1x8c2__neon_mlal_ld4r)
BENCHMARK_GEMM(qs8_gemm_2x8c2__neon_mlal_ld4r)
BENCHMARK_GEMM(qs8_gemm_3x8c2__neon_mlal_ld4r)
BENCHMARK_GEMM(qs8_gemm_4x8c2__neon_mlal_ld4r)
BENCHMARK_GEMM(qs8_gemm_1x16c2__neon_mlal_ld4r)
BENCHMARK_GEMM(qs8_gemm_2x16c2__neon_mlal_ld4r)
BENCHMARK_GEMM(qs8_gemm_3x16c2__neon_mlal_ld4r)
BENCHMARK_GEMM(qs8_gemm_4x16c2__neon_mlal_ld4r)
BENCHMARK_GEMM(qs8_gemm_1x8c2s4__neon_mull)
BENCHMARK_GEMM(qs8_gemm_2x8c2s4__neon_mull)
BENCHMARK_GEMM(qs8_gemm_3x8c2s4__neon_mull)
BENCHMARK_GEMM(qs8_gemm_4x8c2s4__neon_mull)
BENCHMARK_GEMM(qs8_gemm_1x16c2s4__neon_mull)
BENCHMARK_GEMM(qs8_gemm_2x16c2s4__neon_mull)
BENCHMARK_GEMM(qs8_gemm_3x16c2s4__neon_mull)
BENCHMARK_GEMM(qs8_gemm_4x16c2s4__neon_mull)
BENCHMARK_GEMM(qs8_gemm_1x8c2s4__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_2x8c2s4__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_3x8c2s4__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_4x8c2s4__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_1x16c2s4__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_2x16c2s4__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_3x16c2s4__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_4x16c2s4__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_1x8__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_2x8__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_3x8__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_4x8__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_6x8__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_1x16__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_2x16__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_3x16__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_4x16__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_6x16__neon_mlal_lane)
BENCHMARK_GEMM(qs8_gemm_1x8__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_2x8__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_3x8__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_4x8__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_6x8__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_1x16__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_2x16__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_3x16__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_4x16__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_6x16__neon_mlal_lane_prfm)
BENCHMARK_GEMM(qs8_gemm_1x8c8__neon_mull)
BENCHMARK_GEMM(qs8_gemm_2x8c8__neon_mull)
BENCHMARK_GEMM(qs8_gemm_3x8c8__neon_mull)
BENCHMARK_GEMM(qs8_gemm_4x8c8__neon_mull)
BENCHMARK_GEMM(qs8_gemm_1x16c8__neon_mull)
BENCHMARK_GEMM(qs8_gemm_2x16c8__neon_mull)
BENCHMARK_GEMM(qs8_gemm_3x16c8__neon_mull)
BENCHMARK_GEMM(qs8_gemm_4x16c8__neon_mull)
BENCHMARK_GEMM(qs8_gemm_1x8c8__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_2x8c8__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_3x8c8__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_4x8c8__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_1x16c8__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_2x16c8__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_3x16c8__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_4x16c8__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_1x8c16__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_2x8c16__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_3x8c16__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_4x8c16__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_1x16c16__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_2x16c16__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_3x16c16__neon_mlal)
BENCHMARK_GEMM(qs8_gemm_4x16c16__neon_mlal)
#endif // XNN_ARCH_ARM || XNN_ARCH_ARM64
#if XNN_ARCH_ARM
static void qs8_gemm_1x1c4__armsimd32(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_1x1c4__armsimd32,
xnn_init_qs8_conv_minmax_fp32_armsimd32_params,
/*mr=*/1, /*nr=*/1, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckARMV6);
}
static void qs8_gemm_2x1c4__armsimd32(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_1x1c4__armsimd32,
xnn_init_qs8_conv_minmax_fp32_armsimd32_params,
/*mr=*/2, /*nr=*/1, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckARMV6);
}
static void qs8_gemm_1x2c4__armsimd32(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_1x2c4__armsimd32,
xnn_init_qs8_conv_minmax_fp32_armsimd32_params,
/*mr=*/1, /*nr=*/2, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckARMV6);
}
static void qs8_gemm_2x2c4__armsimd32(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_1x2c4__armsimd32,
xnn_init_qs8_conv_minmax_fp32_armsimd32_params,
/*mr=*/2, /*nr=*/2, /*kr=*/4, /*sr=*/1,
benchmark::utils::CheckARMV6);
}
BENCHMARK_GEMM(qs8_gemm_1x1c4__armsimd32)
BENCHMARK_GEMM(qs8_gemm_2x1c4__armsimd32)
BENCHMARK_GEMM(qs8_gemm_1x2c4__armsimd32)
BENCHMARK_GEMM(qs8_gemm_2x2c4__armsimd32)
#endif // XNN_ARCH_ARM
#if XNN_ARCH_X86 || XNN_ARCH_X86_64
static void qs8_gemm_2x16c8__avx512skx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x16c8__avx512skx,
xnn_init_qs8_conv_minmax_fp32_avx512_params,
/*mr=*/2, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX512SKX);
}
static void qs8_gemm_3x16c8__avx512skx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x16c8__avx512skx,
xnn_init_qs8_conv_minmax_fp32_avx512_params,
/*mr=*/3, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX512SKX);
}
static void qs8_gemm_4x16c8__avx512skx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x16c8__avx512skx,
xnn_init_qs8_conv_minmax_fp32_avx512_params,
/*mr=*/4, /*nr=*/16, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX512SKX);
}
static void qs8_gemm_2x8c8__avx2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x8c8__avx2,
xnn_init_qs8_conv_minmax_fp32_avx2_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX2);
}
static void qs8_gemm_3x8c8__avx2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x8c8__avx2,
xnn_init_qs8_conv_minmax_fp32_avx2_params,
/*mr=*/3, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX2);
}
static void qs8_gemm_xw_2x8c8__avx2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x8c8__avx2,
xnn_init_qs8_conv_minmax_fp32_avx2_params,
/*mr=*/2, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX2, true);
}
static void qs8_gemm_xw_3x8c8__avx2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x8c8__avx2,
xnn_init_qs8_conv_minmax_fp32_avx2_params,
/*mr=*/3, /*nr=*/8, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX2, true);
}
static void qs8_gemm_2x4c2__xop_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__xop_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_3x4c2__xop_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__xop_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_4x4c2__xop_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__xop_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_2x4c2__xop_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__xop_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_3x4c2__xop_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__xop_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_4x4c2__xop_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__xop_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_xw_2x4c2__xop(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2__xop,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP, true);
}
static void qs8_gemm_xw_3x4c2__xop(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2__xop,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP, true);
}
static void qs8_gemm_xw_4x4c2__xop(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2__xop,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckXOP, true);
}
static void qs8_gemm_2x4c2s4__xop_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__xop_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_3x4c2s4__xop_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__xop_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_4x4c2s4__xop_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__xop_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_2x4c2s4__xop_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__xop_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_3x4c2s4__xop_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__xop_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_4x4c2s4__xop_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__xop_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_xw_2x4c2s4__xop(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2s4__xop,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP, true);
}
static void qs8_gemm_xw_3x4c2s4__xop(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2s4__xop,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP, true);
}
static void qs8_gemm_xw_4x4c2s4__xop(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2s4__xop,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckXOP, true);
}
static void qs8_gemm_2x4c8__xop_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__xop_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_3x4c8__xop_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__xop_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_2x4c8__xop_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__xop_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_3x4c8__xop_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__xop_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckXOP);
}
static void qs8_gemm_xw_2x4c8__xop(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c8__xop,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckXOP, true);
}
static void qs8_gemm_xw_3x4c8__xop(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c8__xop,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckXOP, true);
}
static void qs8_gemm_2x4c2__avx_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__avx_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_3x4c2__avx_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__avx_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_4x4c2__avx_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__avx_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_2x4c2__avx_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__avx_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_3x4c2__avx_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__avx_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_4x4c2__avx_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__avx_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_xw_2x4c2__avx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2__avx,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX, true);
}
static void qs8_gemm_xw_3x4c2__avx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2__avx,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX, true);
}
static void qs8_gemm_xw_4x4c2__avx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2__avx,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckAVX, true);
}
static void qs8_gemm_2x4c2s4__avx_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__avx_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_3x4c2s4__avx_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__avx_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_4x4c2s4__avx_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__avx_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_2x4c2s4__avx_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__avx_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_3x4c2s4__avx_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__avx_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_4x4c2s4__avx_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__avx_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_xw_2x4c2s4__avx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2s4__avx,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX, true);
}
static void qs8_gemm_xw_3x4c2s4__avx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2s4__avx,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX, true);
}
static void qs8_gemm_xw_4x4c2s4__avx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2s4__avx,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckAVX, true);
}
static void qs8_gemm_2x4c8__avx_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__avx_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_3x4c8__avx_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__avx_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_2x4c8__avx_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__avx_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_3x4c8__avx_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__avx_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX);
}
static void qs8_gemm_xw_2x4c8__avx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c8__avx,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX, true);
}
static void qs8_gemm_xw_3x4c8__avx(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c8__avx,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckAVX, true);
}
static void qs8_gemm_2x4c2__sse41_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__sse41_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_3x4c2__sse41_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__sse41_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_4x4c2__sse41_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__sse41_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_2x4c2__sse41_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__sse41_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_3x4c2__sse41_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__sse41_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_4x4c2__sse41_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__sse41_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_xw_2x4c2__sse41(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2__sse41,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41, true);
}
static void qs8_gemm_xw_3x4c2__sse41(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2__sse41,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41, true);
}
static void qs8_gemm_xw_4x4c2__sse41(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2__sse41,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
benchmark::utils::CheckSSE41, true);
}
static void qs8_gemm_2x4c2s4__sse41_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__sse41_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_3x4c2s4__sse41_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__sse41_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_4x4c2s4__sse41_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__sse41_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_2x4c2s4__sse41_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__sse41_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_3x4c2s4__sse41_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__sse41_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_4x4c2s4__sse41_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__sse41_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_xw_2x4c2s4__sse41(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2s4__sse41,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41, true);
}
static void qs8_gemm_xw_3x4c2s4__sse41(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2s4__sse41,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41, true);
}
static void qs8_gemm_xw_4x4c2s4__sse41(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2s4__sse41,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
benchmark::utils::CheckSSE41, true);
}
static void qs8_gemm_2x4c8__sse41_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__sse41_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_3x4c8__sse41_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__sse41_ld64,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_2x4c8__sse41_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__sse41_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_3x4c8__sse41_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__sse41_ld128,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSE41);
}
static void qs8_gemm_xw_2x4c8__sse41(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c8__sse41,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSE41, true);
}
static void qs8_gemm_xw_3x4c8__sse41(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c8__sse41,
xnn_init_qs8_conv_minmax_fp32_sse4_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSE41, true);
}
static void qs8_gemm_2x4c8__ssse3_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__ssse3_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSSE3);
}
static void qs8_gemm_3x4c8__ssse3_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__ssse3_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSSE3);
}
static void qs8_gemm_2x4c8__ssse3_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__ssse3_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSSE3);
}
static void qs8_gemm_3x4c8__ssse3_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__ssse3_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSSE3);
}
static void qs8_gemm_xw_2x4c8__ssse3(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c8__ssse3,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSSE3, true);
}
static void qs8_gemm_xw_3x4c8__ssse3(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c8__ssse3,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
benchmark::utils::CheckSSSE3, true);
}
static void qs8_gemm_2x4c2__sse2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__sse2_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_3x4c2__sse2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__sse2_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_4x4c2__sse2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__sse2_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_2x4c2__sse2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__sse2_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_3x4c2__sse2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__sse2_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_4x4c2__sse2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__sse2_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_xw_2x4c2__sse2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2__sse2,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_xw_3x4c2__sse2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2__sse2,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_xw_4x4c2__sse2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2__sse2,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_2x4c2s4__sse2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__sse2_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_3x4c2s4__sse2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__sse2_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_4x4c2s4__sse2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__sse2_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_2x4c2s4__sse2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__sse2_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_3x4c2s4__sse2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__sse2_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_4x4c2s4__sse2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__sse2_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_xw_2x4c2s4__sse2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2s4__sse2,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4,
nullptr, true);
}
static void qs8_gemm_xw_3x4c2s4__sse2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2s4__sse2,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4,
nullptr, true);
}
static void qs8_gemm_xw_4x4c2s4__sse2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2s4__sse2,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4,
nullptr, true);
}
static void qs8_gemm_2x4c8__sse2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__sse2_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_3x4c8__sse2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__sse2_ld64,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_2x4c8__sse2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__sse2_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_3x4c8__sse2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__sse2_ld128,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_xw_2x4c8__sse2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c8__sse2,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_xw_3x4c8__sse2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c8__sse2,
xnn_init_qs8_conv_minmax_fp32_sse2_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
nullptr, true);
}
BENCHMARK_GEMM(qs8_gemm_2x16c8__avx512skx)
BENCHMARK_GEMM(qs8_gemm_3x16c8__avx512skx)
BENCHMARK_GEMM(qs8_gemm_4x16c8__avx512skx)
BENCHMARK_GEMM(qs8_gemm_2x8c8__avx2)
BENCHMARK_GEMM(qs8_gemm_3x8c8__avx2)
BENCHMARK_GEMM(qs8_gemm_xw_2x8c8__avx2)
BENCHMARK_GEMM(qs8_gemm_xw_3x8c8__avx2)
BENCHMARK_GEMM(qs8_gemm_2x4c2__xop_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c2__xop_ld64)
BENCHMARK_GEMM(qs8_gemm_4x4c2__xop_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c2__xop_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c2__xop_ld128)
BENCHMARK_GEMM(qs8_gemm_4x4c2__xop_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c2__xop)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c2__xop)
BENCHMARK_GEMM(qs8_gemm_xw_4x4c2__xop)
BENCHMARK_GEMM(qs8_gemm_2x4c8__xop_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c8__xop_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c8__xop_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c8__xop_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c8__xop)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c8__xop)
BENCHMARK_GEMM(qs8_gemm_2x4c2__avx_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c2__avx_ld64)
BENCHMARK_GEMM(qs8_gemm_4x4c2__avx_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c2__avx_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c2__avx_ld128)
BENCHMARK_GEMM(qs8_gemm_4x4c2__avx_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c2__avx)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c2__avx)
BENCHMARK_GEMM(qs8_gemm_xw_4x4c2__avx)
BENCHMARK_GEMM(qs8_gemm_2x4c8__avx_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c8__avx_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c8__avx_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c8__avx_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c8__avx)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c8__avx)
BENCHMARK_GEMM(qs8_gemm_2x4c2__sse41_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c2__sse41_ld64)
BENCHMARK_GEMM(qs8_gemm_4x4c2__sse41_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c2__sse41_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c2__sse41_ld128)
BENCHMARK_GEMM(qs8_gemm_4x4c2__sse41_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c2__sse41)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c2__sse41)
BENCHMARK_GEMM(qs8_gemm_xw_4x4c2__sse41)
BENCHMARK_GEMM(qs8_gemm_2x4c8__sse41_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c8__sse41_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c8__sse41_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c8__sse41_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c8__sse41)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c8__sse41)
BENCHMARK_GEMM(qs8_gemm_2x4c8__ssse3_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c8__ssse3_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c8__ssse3_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c8__ssse3_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c8__ssse3)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c8__ssse3)
BENCHMARK_GEMM(qs8_gemm_2x4c2__sse2_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c2__sse2_ld64)
BENCHMARK_GEMM(qs8_gemm_4x4c2__sse2_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c2__sse2_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c2__sse2_ld128)
BENCHMARK_GEMM(qs8_gemm_4x4c2__sse2_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c2__sse2)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c2__sse2)
BENCHMARK_GEMM(qs8_gemm_xw_4x4c2__sse2)
BENCHMARK_GEMM(qs8_gemm_2x4c8__sse2_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c8__sse2_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c8__sse2_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c8__sse2_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c8__sse2)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c8__sse2)
#endif // XNN_ARCH_X86 || XNN_ARCH_X86_64
#if XNN_ARCH_WASMRELAXEDSIMD
static void qs8_gemm_1x4c16__wasmsdot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c16__wasmsdot,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/1, /*nr=*/4, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckWAsmSDOT);
}
static void qs8_gemm_2x4c16__wasmsdot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c16__wasmsdot,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckWAsmSDOT);
}
static void qs8_gemm_3x4c16__wasmsdot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c16__wasmsdot,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckWAsmSDOT);
}
static void qs8_gemm_4x4c16__wasmsdot(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c16__wasmsdot,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/16, /*sr=*/1,
benchmark::utils::CheckWAsmSDOT);
}
BENCHMARK_GEMM(qs8_gemm_1x4c16__wasmsdot)
BENCHMARK_GEMM(qs8_gemm_2x4c16__wasmsdot)
BENCHMARK_GEMM(qs8_gemm_3x4c16__wasmsdot)
BENCHMARK_GEMM(qs8_gemm_4x4c16__wasmsdot)
#endif // XNN_ARCH_WASMRELAXEDSIMD
#if XNN_ARCH_WASMSIMD || XNN_ARCH_WASMRELAXEDSIMD
static void qs8_gemm_2x4c2__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_3x4c2__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_4x4c2__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_2x4c2__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_3x4c2__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_4x4c2__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1);
}
static void qs8_gemm_xw_2x4c2__wasmsimd_dot16x2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c2__wasmsimd_dot16x2,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_xw_3x4c2__wasmsimd_dot16x2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c2__wasmsimd_dot16x2,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_xw_4x4c2__wasmsimd_dot16x2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c2__wasmsimd_dot16x2,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_2x4c2s4__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_3x4c2s4__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_4x4c2s4__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_2x4c2s4__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c2s4__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_3x4c2s4__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c2s4__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_4x4c2s4__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c2s4__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/2, /*sr=*/4);
}
static void qs8_gemm_2x4c8__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_3x4c8__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_4x4c8__wasmsimd_dot16x2_ld64(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c8__wasmsimd_dot16x2_ld64,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_2x4c8__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4c8__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_3x4c8__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4c8__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_4x4c8__wasmsimd_dot16x2_ld128(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4c8__wasmsimd_dot16x2_ld128,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/8, /*sr=*/1);
}
static void qs8_gemm_xw_2x4c8__wasmsimd_dot16x2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_2x4c8__wasmsimd_dot16x2,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/2, /*nr=*/4, /*kr=*/8, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_xw_3x4c8__wasmsimd_dot16x2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_3x4c8__wasmsimd_dot16x2,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/3, /*nr=*/4, /*kr=*/8, /*sr=*/1,
nullptr, true);
}
static void qs8_gemm_xw_4x4c8__wasmsimd_dot16x2(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_xw_minmax_fp32_ukernel_4x4c8__wasmsimd_dot16x2,
xnn_init_qs8_conv_minmax_fp32_wasmsimd_params,
/*mr=*/4, /*nr=*/4, /*kr=*/8, /*sr=*/1,
nullptr, true);
}
BENCHMARK_GEMM(qs8_gemm_2x4c2__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c2__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_4x4c2__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c2__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c2__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_4x4c2__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c2__wasmsimd_dot16x2)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c2__wasmsimd_dot16x2)
BENCHMARK_GEMM(qs8_gemm_xw_4x4c2__wasmsimd_dot16x2)
BENCHMARK_GEMM(qs8_gemm_2x4c2s4__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c2s4__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_4x4c2s4__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c2s4__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c2s4__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_4x4c2s4__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_2x4c8__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_3x4c8__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_4x4c8__wasmsimd_dot16x2_ld64)
BENCHMARK_GEMM(qs8_gemm_2x4c8__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_3x4c8__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_4x4c8__wasmsimd_dot16x2_ld128)
BENCHMARK_GEMM(qs8_gemm_xw_2x4c8__wasmsimd_dot16x2)
BENCHMARK_GEMM(qs8_gemm_xw_3x4c8__wasmsimd_dot16x2)
BENCHMARK_GEMM(qs8_gemm_xw_4x4c8__wasmsimd_dot16x2)
#endif // XNN_ARCH_WASMSIMD || XNN_ARCH_WASMRELAXEDSIMD
#if XNN_ARCH_WASM || XNN_ARCH_WASMSIMD || XNN_ARCH_WASMRELAXEDSIMD
static void qs8_gemm_2x2__wasm_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x2__wasm_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/2, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_3x2__wasm_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x2__wasm_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/3, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_4x2__wasm_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x2__wasm_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/4, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_2x4__wasm_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4__wasm_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/2, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_3x4__wasm_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4__wasm_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/3, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_4x4__wasm_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4__wasm_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/4, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
BENCHMARK_GEMM(qs8_gemm_2x2__wasm_fmagic)
BENCHMARK_GEMM(qs8_gemm_3x2__wasm_fmagic)
BENCHMARK_GEMM(qs8_gemm_4x2__wasm_fmagic)
BENCHMARK_GEMM(qs8_gemm_2x4__wasm_fmagic)
BENCHMARK_GEMM(qs8_gemm_3x4__wasm_fmagic)
BENCHMARK_GEMM(qs8_gemm_4x4__wasm_fmagic)
#endif // XNN_ARCH_WASM || XNN_ARCH_WASMSIMD || XNN_ARCH_WASMRELAXEDSIMD
static void qs8_gemm_2x2__scalar_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x2__scalar_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/2, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_3x2__scalar_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x2__scalar_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/3, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_4x2__scalar_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x2__scalar_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/4, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_2x4__scalar_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4__scalar_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/2, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_3x4__scalar_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4__scalar_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/3, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_4x4__scalar_fmagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4__scalar_fmagic,
xnn_init_qs8_conv_minmax_fp32_scalar_fmagic_params,
/*mr=*/4, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_2x2__scalar_imagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x2__scalar_imagic,
xnn_init_qs8_conv_minmax_fp32_scalar_imagic_params,
/*mr=*/2, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_3x2__scalar_imagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x2__scalar_imagic,
xnn_init_qs8_conv_minmax_fp32_scalar_imagic_params,
/*mr=*/3, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_4x2__scalar_imagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x2__scalar_imagic,
xnn_init_qs8_conv_minmax_fp32_scalar_imagic_params,
/*mr=*/4, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_2x4__scalar_imagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4__scalar_imagic,
xnn_init_qs8_conv_minmax_fp32_scalar_imagic_params,
/*mr=*/2, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_3x4__scalar_imagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4__scalar_imagic,
xnn_init_qs8_conv_minmax_fp32_scalar_imagic_params,
/*mr=*/3, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_4x4__scalar_imagic(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4__scalar_imagic,
xnn_init_qs8_conv_minmax_fp32_scalar_imagic_params,
/*mr=*/4, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_2x2__scalar_lrintf(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x2__scalar_lrintf,
xnn_init_qs8_conv_minmax_fp32_scalar_lrintf_params,
/*mr=*/2, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_3x2__scalar_lrintf(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x2__scalar_lrintf,
xnn_init_qs8_conv_minmax_fp32_scalar_lrintf_params,
/*mr=*/3, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_4x2__scalar_lrintf(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x2__scalar_lrintf,
xnn_init_qs8_conv_minmax_fp32_scalar_lrintf_params,
/*mr=*/4, /*nr=*/2, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_2x4__scalar_lrintf(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_2x4__scalar_lrintf,
xnn_init_qs8_conv_minmax_fp32_scalar_lrintf_params,
/*mr=*/2, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_3x4__scalar_lrintf(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_3x4__scalar_lrintf,
xnn_init_qs8_conv_minmax_fp32_scalar_lrintf_params,
/*mr=*/3, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
static void qs8_gemm_4x4__scalar_lrintf(benchmark::State& state, const char* net) {
GEMMBenchmark(state,
xnn_qs8_gemm_minmax_fp32_ukernel_4x4__scalar_lrintf,
xnn_init_qs8_conv_minmax_fp32_scalar_lrintf_params,
/*mr=*/4, /*nr=*/4, /*kr=*/1, /*sr=*/1);
}
BENCHMARK_GEMM(qs8_gemm_2x2__scalar_fmagic)
BENCHMARK_GEMM(qs8_gemm_3x2__scalar_fmagic)
BENCHMARK_GEMM(qs8_gemm_4x2__scalar_fmagic)
BENCHMARK_GEMM(qs8_gemm_2x4__scalar_fmagic)
BENCHMARK_GEMM(qs8_gemm_3x4__scalar_fmagic)
BENCHMARK_GEMM(qs8_gemm_4x4__scalar_fmagic)
BENCHMARK_GEMM(qs8_gemm_2x2__scalar_imagic)
BENCHMARK_GEMM(qs8_gemm_3x2__scalar_imagic)
BENCHMARK_GEMM(qs8_gemm_4x2__scalar_imagic)
BENCHMARK_GEMM(qs8_gemm_2x4__scalar_imagic)
BENCHMARK_GEMM(qs8_gemm_3x4__scalar_imagic)
BENCHMARK_GEMM(qs8_gemm_4x4__scalar_imagic)
BENCHMARK_GEMM(qs8_gemm_2x2__scalar_lrintf)
BENCHMARK_GEMM(qs8_gemm_3x2__scalar_lrintf)
BENCHMARK_GEMM(qs8_gemm_4x2__scalar_lrintf)
BENCHMARK_GEMM(qs8_gemm_2x4__scalar_lrintf)
BENCHMARK_GEMM(qs8_gemm_3x4__scalar_lrintf)
BENCHMARK_GEMM(qs8_gemm_4x4__scalar_lrintf)
#ifdef BENCHMARK_RUY
BENCHMARK_GEMM(ruy_st)
#endif // BENCHMARK_RUY
#ifndef XNNPACK_BENCHMARK_NO_MAIN
BENCHMARK_MAIN();
#endif
|
[
"[email protected]"
] | |
72e04b01ee0577c612288769ef62e129716b7574
|
16450d59c820298f8803fd40a1ffa2dd5887e103
|
/HongC++/HongChapter6/Chapter6_2/Chapter6_2.cpp
|
fb104396402af0d94764afef31b413d60da329c8
|
[] |
no_license
|
egyeasy/TIL_public
|
f78c11f81d159eedb420f5fa177c05d310c4a039
|
e2f40eda09cb0a65cc064d9ba9b0e2fa7cbbcb38
|
refs/heads/master
| 2021-06-21T01:22:16.516777 | 2021-02-02T13:16:21 | 2021-02-02T13:16:21 | 167,803,551 | 0 | 0 | null | null | null | null |
UHC
|
C++
| false | false | 828 |
cpp
|
#include <iostream>
using namespace std;
void doSomething(int students_scores[]) // size 표시하지 않아도 됨
{
cout << students_scores[0] << endl;
cout << students_scores[1] << endl;
cout << students_scores[2] << endl;
cout << (int)&students_scores << endl;
cout << "size: " << sizeof(students_scores) << endl;
}
int main()
{
const int num_students = 20;
int students_scores[num_students] = { 1, 2, 3, 4, 5 };
cout << (int)&students_scores << endl; // +0
cout << (int) & (students_scores[0]) << endl; // +0
cout << (int) & (students_scores[1]) << endl; // +4
cout << (int) & (students_scores[2]) << endl; // +8
cout << (int) & (students_scores[3]) << endl; // +12
cout << "size: " << sizeof(students_scores) << endl;
doSomething(students_scores); // 함수의 인자로 전달 가능
return 0;
}
|
[
"[email protected]"
] | |
84db25ec1f9dc981fd8be26ec065786a26e3ef02
|
9566ad44b5ed5aa689354f4804bd68e3370255df
|
/trview.app/Tools/IMeasure.h
|
3fb2c92a4a8b5a629ca55b2d90d3787d3d272b6f
|
[
"MIT",
"Zlib",
"BSL-1.0"
] |
permissive
|
hxdaze/trview
|
c7ddd350de3aba8ca9c4e6c81337cdc68348ed77
|
fd3dd0830521ff9312e5d969ffea3e722750e10f
|
refs/heads/master
| 2023-06-25T04:46:34.977789 | 2021-07-22T21:36:47 | 2021-07-22T21:36:47 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,839 |
h
|
#pragma once
#include <SimpleMath.h>
#include <trview.common/Event.h>
#include <trview.app/Camera/ICamera.h>
#include <trview.app/Graphics/ILevelTextureStorage.h>
namespace trview
{
struct IMeasure
{
virtual ~IMeasure() = 0;
/// Event raised when the measure distance has changed.
Event<float> on_distance;
/// Event raised when the measure visibility has changed.
Event<bool> on_visible;
/// Event raised when the measure label position has moved.
Event<Point> on_position;
/// Start measuring or reset the current measurement.
virtual void reset() = 0;
/// Add the position to the measurement.
/// @param position The position to add to the measurement.
/// @returns True if the measurement is complete.
virtual bool add(const DirectX::SimpleMath::Vector3& position) = 0;
/// Set the position as the current temporary end of the measurement.
/// @param position The position to use as the new end.
virtual void set(const DirectX::SimpleMath::Vector3& position) = 0;
/// Render the measurement.
/// @param camera The camera being used to render the scene.
/// @param texture_storage Texture storage for the level.
virtual void render(const ICamera& camera, const ILevelTextureStorage& texture_storage) = 0;
/// Get the current text version of the distance measured.
/// @returns The text version of the distance.
virtual std::wstring distance() const = 0;
/// Get whether a distance is actively being measured.
/// @returns True if start and end is set.
virtual bool measuring() const = 0;
/// Set whether the measure tool should be rendered.
virtual void set_visible(bool value) = 0;
};
}
|
[
"[email protected]"
] | |
0a19a2376aca29679bbe1d65b825b2877640ed41
|
c65251aafac2452de89b33a97018f5fc07d19830
|
/tests/unit/termination/test_termination_action_common.h
|
e83527c81892c3bc2c9ad595a796fd4ff7a3a7f7
|
[
"BSD-2-Clause"
] |
permissive
|
PhilMiller/vt
|
b0454520e8d0a31ca8ccd8b3cb37eea2018c029a
|
9a5983cc884b998e313b741acc7c3d03916207cf
|
refs/heads/master
| 2020-07-22T19:30:45.905074 | 2019-08-14T21:48:49 | 2019-08-14T21:48:49 | 207,304,466 | 0 | 0 | null | 2019-09-09T12:32:37 | 2019-09-09T12:32:36 | null |
UTF-8
|
C++
| false | false | 4,819 |
h
|
/*
//@HEADER
// ************************************************************************
//
// test_termination_action_common.h
// vt (Virtual Transport)
// Copyright (C) 2018 NTESS, LLC
//
// Under the terms of Contract DE-NA-0003525 with NTESS, LLC,
// the U.S. Government retains certain rights in this software.
//
// 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 Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "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 SANDIA CORPORATION OR THE
// 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.
//
// Questions? Contact [email protected]
//
// ************************************************************************
//@HEADER
*/
#include <gtest/gtest.h>
#include <random>
#include <vector>
#include "test_parallel_harness.h"
#include "test_termination_channel_counting.h"
#if !defined INCLUDED_TERMINATION_ACTION_COMMON_H
#define INCLUDED_TERMINATION_ACTION_COMMON_H
using namespace vt::tests::unit;
// set channel counting ranks
vt::NodeType channel::root = vt::uninitialized_destination;
vt::NodeType channel::node = vt::uninitialized_destination;
vt::NodeType channel::all = vt::uninitialized_destination;
std::unordered_map<vt::EpochType,channel::Data> channel::data;
/*
* common actions and fixtures for:
* - global termination
* - rooted/collect epoch termination
* - nested epochs termination.
*/
namespace vt { namespace tests { namespace unit { namespace action {
// shortcuts
using epoch_manip = ::vt::epoch::EpochManip;
using Base = TestParallelHarnessParam<std::tuple<int, bool, int>>;
static bool ok = false;
struct BaseFixture : Base {
void SetUp() override {
// explicit inheritance
Base::SetUp();
// set channel counting ranks
channel::root = 0;
channel::node = vt::theContext()->getNode();
channel::all = vt::theContext()->getNumNodes();
vtAssert(channel::all > 1, "There should be at least two nodes");
// retrieve test parameters
auto const& values = GetParam();
order_ = std::get<0>(values);
useDS_ = std::get<1>(values);
depth_ = std::get<2>(values);
debug_print(
term, node,
"BaseFixture::setup: order_={}, useDS_={}, depth_={}\n",
order_, useDS_, depth_
);
}
protected:
int order_ = 0;
bool useDS_ = false;
int depth_ = 1;
};
struct SimpleFixture : TestParallelHarness {
void SetUp() override {
// explicit inheritance
TestParallelHarness::SetUp();
// set channel counting ranks
channel::root = 0;
channel::node = vt::theContext()->getNode();
channel::all = vt::theContext()->getNumNodes();
vtAssert(channel::all > 1, "Should use at least two nodes");
}
};
// epoch sequence creation
std::vector<vt::EpochType> generateEpochs(
int nb = 1, bool rooted = false, bool useDS = false
);
// fictive distributed computation
void compute(vt::EpochType const& epoch);
// add the termination checker algorithm as a pending action
void add(vt::EpochType const& epoch, int order);
// finish the epoch
void finish(vt::EpochType const& epoch);
// set the flag indicating that the current
// epoch of the sequence is finished
inline void setOk(vt::Message* /*unused*/) { ok = true; }
/*
* at the end of a given epoch:
* - assign action to be processed
* - trigger termination detection
* - finish epoch
*/
void finalize(vt::EpochType const& epoch, int order);
}}}} // end namespace vt::tests::unit::action
#include "test_termination_action_common.impl.h"
#endif /*INCLUDED_TERMINATION_ACTION_COMMON_H*/
|
[
"[email protected]"
] | |
65c21d225150bf09d5ed43bb4b77723340aff576
|
b907b0036bd032dee180cc321424a2d35d83e761
|
/Win/MainWnd.cpp
|
1e615955ebc006787ab7b50a5f0f8778dad136d0
|
[] |
no_license
|
15831944/garage
|
9a495c8061b159036c13a1e06f2830257a2242d5
|
4745e5c88107b7051756f41fea47ff85e8754dbf
|
refs/heads/master
| 2021-12-10T20:39:28.283284 | 2016-09-19T14:30:19 | 2016-09-19T14:30:19 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 125 |
cpp
|
// MainWnd.cpp
#include "MainWnd.h"
int WINAPI _tWinMain( HINSTANCE hInstance, HINSTANCE, PTSTR, int )
{
CMainWnd main;
}
|
[
"[email protected]"
] | |
3b45853b85e71a58ab3b15540da5c6bc5f7e8e25
|
d9967671c30d9e6215f47f769e47af1bf3fb2bf6
|
/lista_compiladas/05_laco_math/testes.cpp
|
05d14c9112b2f6d2423e8b97428ea0cefce72a6c
|
[] |
no_license
|
senapk/arcade
|
4b6af60e43d9132e8c0c063870786c806005eb00
|
fcc6af8e9e3e260b64deafb728563a112fc44b6d
|
refs/heads/master
| 2016-09-06T17:52:39.143242 | 2015-12-16T22:05:28 | 2015-12-16T22:05:28 | 24,432,199 | 0 | 0 | null | 2014-10-15T17:10:40 | 2014-09-24T20:51:47 |
C++
|
UTF-8
|
C++
| false | false | 14,411 |
cpp
|
#include "questoes.cpp"
namespace _1_soma_condicional{
//@tests
auto feq = [](float A, float B)->bool{return ((max(A,B)-min(A,B)) < 0.01);};
void tests() {
cerr << ("#open soma_condicional") << endl;
cerr << ("#set PRATA FOR IF") << endl;
cerr << (impares_3_500() == 83);
cerr << endl;
cerr << ("#open contar_div3") << endl;
cerr << ("#set PRATA FOR IF") << endl;
cerr << (contar_div3(10,20) == 3);
cerr << (contar_div3(100,103) == 1);
cerr << endl;
cerr << ("#open contar_div23x") << endl;
cerr << ("#set PRATA FOR IF") << endl;
cerr << (contar_div23x(1,20,30) == 2);
cerr << (contar_div23x(4,10,12) == 1);
}
}
namespace _1_soma_criterio{
//@tests
void tests() {
cerr << "#open soma_divisiveis" << endl;
cerr << (soma_divisiveis(3) == 3);
cerr << (soma_divisiveis(10) == 18);
cerr << (soma_divisiveis(20) == 63);
}
}
namespace _1_somas{
//@tests
auto feq = [](float A, float B)->bool{return ((max(A,B)-min(A,B)) < 0.01);};
void tests() {
cerr << ("#open somatorio_0_a_num") << endl;
cerr << ("#set BRONZE FOR") << endl;
cerr << (somatorio_0_a_num(10) == 55);
cerr << (somatorio_0_a_num(1) == 1);
cerr << (somatorio_0_a_num(3) == 6);
cerr << (somatorio_0_a_num(5) == 15);
cerr << endl;
cerr << "#open somatorio_x_y BRONZE FOR" << endl;
cerr << (somatorio_x_y(9, 10) == 19);
cerr << (somatorio_x_y(1, 3) == 6);
cerr << (somatorio_x_y(4, 7) == 22);
}
}
namespace _2_conta_digitos{
void tests()
{
cerr << "#open conta_digito" << endl;
cerr << (conta_digito(2,99102030) == 1);
cerr << (conta_digito(1,99123321) == 2);
cerr << (conta_digito(9,95398900) == 3);
}
}
namespace _2_conta{
//@tests
void tests(){
cerr << "#open conta BRONZE IF FOR" << endl;
cerr << (conta(101) == 172);
cerr << (conta(50) == 67);
cerr << (conta(0) == 7);
cerr << (conta(20) == 17);
}
}
namespace _2_eh_primo{
//@tests
void tests() {
cerr << ("#open eh_primo") << endl;
cerr << ("#set PRATA IF FOR") << endl;
cerr << (eh_primo(5) == true);
cerr << (eh_primo(3) == true);
cerr << (eh_primo(0) == false);
cerr << (eh_primo(2) == true);
}
}
namespace _2_fatorial{
void tests() {
cerr << ("#open fatorial") << endl;
cerr << ("#set PRATA FOR") << endl;
cerr << (fatorial(1) == 1);
cerr << (fatorial(2) == 2);
cerr << (fatorial(3) == 6);
}
}
namespace _2_multiplos_3_5{
//@tests
void tests(){
cerr << "#open mult_3_5 BRONZE IF FOR" << endl;
cerr << (mult_3_5(10) == 23);
cerr << (mult_3_5(11) == 33);
cerr << (mult_3_5(12) == 33);
}
}
namespace _2_numeracao_porta{
//@tests
void tests(){
cerr << "#open numeracao_porta BRONZE" << endl;
cerr << (numeracao_porta(1) == 1);
cerr << (numeracao_porta(2) == 1);
cerr << (numeracao_porta(3) == 2);
cerr << (numeracao_porta(4) == 3);
cerr << (numeracao_porta(5) == 5);
cerr << (numeracao_porta(6) == 8);
}
}
namespace _2_soma_fib{
void tests()
{
cerr << ("#open fibonatti PRATA IF FOR") << endl;
cerr << (fibo(3) == 6);
cerr << (fibo(4) == 11);
}
}
namespace _3_binario_decimal{
void tests()
{
cerr << ("#open binario-decimal PRATA FOR") << endl;
cerr << (binario_decimal(0) == 0);
cerr << (binario_decimal(1) == 1);
cerr << (binario_decimal(11) == 3);
cerr << (decimal_binario(0) == 0);
cerr << (decimal_binario(1) == 1);
cerr << (decimal_binario(2) == 10);
cerr << (decimal_binario(3) == 11);
}
}
namespace _3_bissexto{
void tests() {
cerr << "#open eh_bissexto BRONZE IF FOR" << endl;
cerr << (eh_bissexto("2000") == true);
cerr << (eh_bissexto("1188") == true);
cerr << (eh_bissexto("2004") == true);
}
}
namespace _3_eh_quadrado{
//@tests
void tests() {
cerr << ("#open distancia_pontos") << endl;
cerr << ("#set BRONZE IF FOR") << endl;
cerr << (eh_quadrado_perfeito(0) == false);
cerr << (eh_quadrado_perfeito(1) == true);
cerr << (eh_quadrado_perfeito(2) == false);
cerr << (eh_quadrado_perfeito(3) == false);
cerr << (eh_quadrado_perfeito(140) == false);
cerr << (eh_quadrado_perfeito(6084) == true);
}
}
namespace _3_fetuccine{
void tests()
{
cerr << ("#open fetuccine PRATA FOR IF ");
cerr << (fetuccine(1,1,10) == 5);
cerr << (fetuccine(1,2,10) == 7);
cerr << (fetuccine(3,5,10) == 19);
}
}
namespace _3_inversao_numeros{
void tests()
{
cerr << ("#open inversao PRATA IF FOR") << endl;
cerr << (espelho_de_numeros(1234) == 4321);
cerr << (espelho_de_numeros(43254) == 45234);
}
}
namespace _3_mdc{
//@tests
void tests(){
cerr << "#open mdc BRONZE IF FOR" << endl;
cerr << (mdc(1,1) == 1);
cerr << (mdc(1,2) == 1);
cerr << (mdc(2,4) == 2);
cerr << (mdc(20,40) == 20);
}
}
namespace _3_naoprimo_primo{
//@tests
void tests() {
cerr << "#open nao_primo_menos_primo PRATA IF FOR" << endl;
cerr << (nao_primo_menos_primo(0) == 0);
cerr << (nao_primo_menos_primo(1) == 1);
cerr << (nao_primo_menos_primo(4) == 0);
cerr << (nao_primo_menos_primo(3) == -4);
}
}
namespace _3_palindrome{
//@tests
void tests(){
cerr << "#open id_palindrome BRONZE IF FOR" << endl;
cerr << (id_palindrome(121) == true);
cerr << (id_palindrome(122) == false);
cerr << (id_palindrome(1) == true);
cerr << (id_palindrome(11) == true);
cerr << (id_palindrome(1235321) == true);
}
}
namespace _3_permutacao{
void tests()
{
cerr << ("#open permutacao BRONZE IF FOR ") << endl;
cerr << (permutacao(1,1) == true);
cerr << (permutacao(1,2) == false);
cerr << (permutacao(34,2) == false);
cerr << (permutacao(1,0) == false);
cerr << (permutacao(1234,2314) == true);
}
}
namespace _3_rotaciona_crip{
//@tests
void tests(){
cerr << "#open rotaciona_crip BRONZE IF FOR" << endl;
cerr << (rotaciona_crip(1,2) == 3);
cerr << (rotaciona_crip(13,2) == 35);
cerr << (rotaciona_crip(9,2) == 1);
cerr << (rotaciona_crip(9,1) == 0);
}
}
namespace _3_rotacoes{
void tests()
{
cerr <<("#open rotacoes PRATA FOR IF") << endl;
cerr << (RE(1234) == 4123);
cerr << (RE(4234) == 4423);
cerr << (RD(1234) == 2341);
cerr << (RD(2345) == 3452);
cerr << (RD(1112) == 1121);
}
}
namespace _3_soma_achados{
//@tests
void tests(){
//Questão 01
cerr << "#open soma4 BRONZE IF FOR" << endl;
cerr << (soma4(1) == 20);
cerr << (soma4(8) == 52);
cerr << endl;
//Questão 02
cerr << "#open soma10 BRONZE IF FOR" << endl;
cerr << (soma10(0) == 165);
cerr << (soma10(3) == 195);
cerr << endl;
//Questão 03
cerr << "#open somaxyz BRONZE IF FOR" << endl;
cerr << (somaxyz(20,3,2) == 72);
cerr << (somaxyz(0,1,2) == 2);
cerr << endl;
}
}
namespace _3_soma_primos{
//@tests
auto feq = [](float A, float B)->bool{return ((max(A,B)-min(A,B)) < 0.01);};
void tests() {
cerr << ("#open soma_primos") << endl;
cerr << ("#set BRONZE IF FOR") << endl;
cerr << (primeiros_primos(1, 5) == 3);
cerr << (primeiros_primos(6, 12) == 2);
cerr << (primeiros_primos(11, 18) == 2);
}
}
namespace _4_numero_harmonico{
void tests()
{
cerr << ("#open numero_harmonico PRATA FOR");
cerr << (numero_harmonico(3) > 1.83 && numero_harmonico(3) < 1.84);
cerr << (numero_harmonico(6) > 2.45 && numero_harmonico(6) < 2.46);
}
}
//@question 1_soma_condicional
//Use uma variável que será usada como contador e incremente ela quando o numero for divisível pelos
//parâmetros passados.
//Depois retorne essa variável.
//@question 1_soma_criterio
//Use o operador de módulo (%) para saber se um
//numéro é divisível por outro. Use uma variável
//auxiliar para guardar a soma.
//@question 1_somas
//Use uma variável auxiliar que guarda a soma de cada número interado em um laço.
//@question 2_conta_digitos
//Dica: Para pegar o primeiro numero da direita pra esquerda no valor,
//você pode usar o operador MOD, depois é só pegar todos
//e verificar a ocorrencia de um outro numero
//@question 2_conta
//Dica: Compare os valores em um laço com n > 10, pois o 10 já é o padrão da franquia.
//@question 2_eh_primo
//Um número só é primo quando é divisível por 1 e por ele msm,
//então se as demais divisões forem exatas, ele não será primo.
//@question 2_fatorial
//O fatorial de um número é sua multiplicação pelos demais números
//em ordem decrescente até o 1.
//Exemplo: 5! = 5 * 4 * 3 * 2 * 1 OU 1 * 2 * 3 * 4 * 5 = 120
//Lembrando que a ordem não altera o resultado.
//@question 2_numeracao_porta
// Para obter a serie de fibonnaci, você precisa de 3 variaveis, a primeira referente ao valor que voce vai "aumentar",
// a segunda referente ao seu anterior e a ultima referente a anterior da anterior, para "aumentar" a primeira você
// precisa das outras duas, depois que aumenta-la, você precisa atualizar o valor das outras duas corretamente, para lembra-lo
// a serie de fibonnaci é a seguinte:
// 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, … (podendo ser omitido o zero inicial).
//@question 2_soma_fib
// A sequencia de fibonatti leva em conta a soma dos dois termos anteriores
// a partir da terceira posição, se forem a posicao 1 e 2, estes tem valor
// diferenciado, respectivamente 1 e 2.
//@question 3_binario_decimal
//Dica Binario-decimal: Existe uma tecnica para se converter de binario pra decimal que consiste em:
//você coloca todos os 0s e 1s numa fila, depois acima deles é só colocar todas as potencias de 2 comerçando pelo 1
//acima deles da direita pra esquerda, depois é só somar aquelas potencias que estiverem com um 1 abaixo e você terá
//seu resultado:
//Multiplos>>> 64 32 16 8 4 2 1
//Binario>>>>> 0 1 0 1 1 0 1
//ou seja, o numero 0101101 em decimal é 32 + 8 + 4 + 1 = 45
//Dica Decimal-binario: voce pegara o modulo de 2 do numero e saira adicionando da
//esquerda para a direita, depois você dividirá por 2 até que o numero não seja mais divisivel.
//@question 3_bissexto
//Dica: Os anos bissexto são múltiplos de 4 e não múltiplos de 100,
//mas podem ser múltiplos de 400.
//@question 3_eh_quadrado
//Para saber mais sobre os quadrados perfeitos acesse:
//http://clubes.obmep.org.br/blog/quadrado-perfeito/
//@question 3_fetuccine
//Você vai criar uma condição
//que executará de uma forma caso o indice do numero for impar e de outra forma caso for par, para os dois primeiros
//valores iguais a 1 ou sejá, 1º igual a 1 e o 2º igul a 1 a seguência fica da seguinte forma:
//1 , 1 , 2 , 1 , 3 , 2 , 5 , 3 , 8 , 5...
//@question 3_inversao_numeros
//Dica: Você criar uma variavel auxiliar, depois adicionaria nessa variavel,
//o modulo de 10 do numero, onde ele daria o valor do ultimo algarismo,
//dividiria por 10, e continuaria o processo adicionando sempre o ultimo numero
//a variavel, lembrando de tratar as posições de cada um.
//@question 3_mdc
//Vai dividindo até encontrar um numero que sejá igual ou menor ao menor dos dois numeros que divide os dois,
//talvez sejá preciso vc ir armazenando o que dar pra dividir, caso nenhum que é igual ao menor dar pra dividir.
//Para saber mais acesse:
//http://www.somatematica.com.br/fundam/mdc.php
//@question 3_naoprimo_primo
//tips: Faça uma função auxiliar que recebe um número por parâmetro e retorna se ele é primo ou não.
//Use a função citada a cima em um laço e se o número for primo some ele em uma variável auxiliar, se não some
//com outra variável auxiliar depois retorne a diferença entre as duas.
//@question 3_palindrome
//Para saber mais sobre números palindromos acesse:
//http://matematicaenigmatica.blogspot.com.br/2009/11/numeros-palindromos-ou-capicua.html
//@question 3_permutacao
//Você tem apenas que saber quantas vezes um determinado numero aparece no primeiro valor e no segundo valor,
//caso essa quandidade sejam diferentes, você retorn false, faça isso para todos os numeros do primeiro ou segundo valor..
//@question 3_rotacoes
//Dica RE: Você só precisa retirar o primeira numero da direita para a esquerda,
//"transforma-lo" usando uma "grandeza" e soma-lo ao resto que sobrar
//Dica RD: Retire o primeiro numero da esquerda pra direita e some esse
//numero ao valor que restar depois da remorção.
//@question 3_soma_achados
//Dica: Se lembre do operador de módulo ( % ) que retorna do resto da divisão de um número por outro.
//@question 3_soma_primos
//Faça uma função auxiliar que retorne true ou false se o numero passado for primo ou não.
//Use essa função auxiliar para cada elemento i entre x+1 e y.
//Se o numero for primo incremente um contador e no final retorne o mesmo.
//Para saber mais sobre os números primos acesse:
//http://www.somatematica.com.br/fundam/primos.php
//@question 4_numero_harmonico
//Na fração, o numerador é constante e o denominador e variante.
int main(){
_1_soma_condicional::tests();
_1_soma_criterio::tests();
_1_somas::tests();
_2_conta_digitos::tests();
_2_conta::tests();
_2_eh_primo::tests();
_2_fatorial::tests();
_2_multiplos_3_5::tests();
_2_numeracao_porta::tests();
_2_soma_fib::tests();
_3_binario_decimal::tests();
_3_bissexto::tests();
_3_eh_quadrado::tests();
_3_fetuccine::tests();
_3_inversao_numeros::tests();
_3_mdc::tests();
_3_naoprimo_primo::tests();
_3_palindrome::tests();
_3_permutacao::tests();
_3_rotaciona_crip::tests();
_3_rotacoes::tests();
_3_soma_achados::tests();
_3_soma_primos::tests();
_4_numero_harmonico::tests();
cerr << "#end" << endl;
return 0;
}
|
[
"[email protected]"
] | |
944c0dce219fb03d298a0e5de267eb4daf9f16e7
|
fb70ac3242f1296408ec709e4a5b2fc3ef16bd4b
|
/bin/windows.build/cpp/include/phoenix/geometry/RingGeometry.h
|
04e7fad6c1e7724934088d567f4ac894d8583946
|
[] |
no_license
|
desttinghim/luxeout
|
bc4dfb29efd72c0b62bcacb2add4cf89cccef63e
|
9bfa2bc2666a3d1b55169870cbca535c94901540
|
refs/heads/master
| 2020-05-19T09:05:51.552189 | 2015-01-08T21:03:07 | 2015-01-08T21:03:07 | 28,525,348 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,339 |
h
|
#ifndef INCLUDED_phoenix_geometry_RingGeometry
#define INCLUDED_phoenix_geometry_RingGeometry
#ifndef HXCPP_H
#include <hxcpp.h>
#endif
#include <phoenix/geometry/CircleGeometry.h>
HX_DECLARE_CLASS2(phoenix,geometry,CircleGeometry)
HX_DECLARE_CLASS2(phoenix,geometry,Geometry)
HX_DECLARE_CLASS2(phoenix,geometry,RingGeometry)
namespace phoenix{
namespace geometry{
class HXCPP_CLASS_ATTRIBUTES RingGeometry_obj : public ::phoenix::geometry::CircleGeometry_obj{
public:
typedef ::phoenix::geometry::CircleGeometry_obj super;
typedef RingGeometry_obj OBJ_;
RingGeometry_obj();
Void __construct(Dynamic options);
public:
inline void *operator new( size_t inSize, bool inContainer=true)
{ return hx::Object::operator new(inSize,inContainer); }
static hx::ObjectPtr< RingGeometry_obj > __new(Dynamic options);
static Dynamic __CreateEmpty();
static Dynamic __Create(hx::DynamicArray inArgs);
//~RingGeometry_obj();
HX_DO_RTTI;
static void __boot();
static void __register();
::String __ToString() const { return HX_CSTRING("RingGeometry"); }
virtual Void set( Float _x,Float _y,Float _rx,Float _ry,int _steps,hx::Null< Float > _start_angle_degrees,hx::Null< Float > _end_angle_degrees);
};
} // end namespace phoenix
} // end namespace geometry
#endif /* INCLUDED_phoenix_geometry_RingGeometry */
|
[
"[email protected]"
] | |
009b74c00a139aad0566e38719816191a719e6fc
|
6a00799b81bb00c868c460b83fd4ef8573732c97
|
/Lobby/netdrv/source/KwNetStreamPointer.cpp
|
610661a9d74adb95e8bd3779487fc28974f94954
|
[] |
no_license
|
callmechiefdom/FBServer
|
875f209406ebcc9ad193e63ab04795b9c99e6d07
|
20d617889bacadea57dc27c3a6c9eea7151a6ae2
|
refs/heads/master
| 2021-09-15T15:28:34.318580 | 2018-06-05T17:38:17 | 2018-06-05T17:38:17 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,684 |
cpp
|
#include "KwNetPrivate.h"
#include "KwNetStreamPointer.h"
StreamPointer::StreamPointer( uchar* pBuf, uint32 uHead, uint32 uTail, uint32 uBufMaxSize )
{
m_pPointer = pBuf;
m_uHead = uHead;
m_uTail = uTail;
m_uBufMaxSize = uBufMaxSize;
}
StreamPointer::~StreamPointer()
{}
uchar* StreamPointer::GetPointer()
{
return m_pPointer+m_uHead;
}
uchar* StreamPointer::GetPointer(uint32 offset)
{
uint32 uHead = m_uHead + offset;
if( uHead >= m_uBufMaxSize )
{
uHead = uHead - m_uBufMaxSize;
}
return m_pPointer+uHead;
}
StreamPointer& StreamPointer::operator += (uint32 u)
{
m_uHead += u;
if( m_uHead >= m_uBufMaxSize )
{
m_uHead = m_uHead - m_uBufMaxSize;
}
return *this;
}
StreamPointer& StreamPointer::operator ++ ()
{
m_uHead ++;
if( m_uHead >= m_uBufMaxSize )
{
m_uHead = m_uHead - m_uBufMaxSize;
}
return *this;
}
void StreamPointer::CopyData(uchar* pDst,uint32 uSize)
{
uint32 uRealSize = GetSize();
if( uSize > uRealSize )
uSize = uRealSize;
uint32 uLeftSize = 0;
if( m_uTail >= m_uHead )
{
uLeftSize = m_uTail - m_uHead;
if( uLeftSize > uSize )
uLeftSize = uSize;
memcpy( pDst, GetPointer(), uLeftSize );
}
else
{
uLeftSize = m_uBufMaxSize - m_uHead;
if( uLeftSize >= uSize )
{
memcpy( pDst, GetPointer(), uSize );
}
else
{
memcpy( pDst, GetPointer(), uLeftSize );
memcpy( pDst+uLeftSize, GetPointer(uLeftSize), uSize-uLeftSize );
}
}
}
uint32 StreamPointer::GetSize()
{
uint32 uSize = 0;
if( m_uTail >= m_uHead )
uSize = m_uTail - m_uHead;
else
uSize = m_uBufMaxSize - m_uHead + m_uTail;
return uSize;
}
|
[
"[email protected]"
] | |
d4ad8e9fbd895aa105fed0dd6dd3914f9e0e86ce
|
e2a8b3bb46535a6e90fbe244757853ff9bf1adb6
|
/Classes/SoundManager.cpp
|
b9d058a5fc0a7535c5b93c5649c4c3217e0abb4a
|
[] |
no_license
|
yantian001/testaudio
|
6eb11ff07c17bf634a7a20f266841aa5862757ba
|
7e27204e137ed422f2f4e0911d75b71fa83584cc
|
refs/heads/master
| 2016-09-06T16:02:12.966070 | 2015-03-04T09:12:18 | 2015-03-04T09:12:18 | 31,647,846 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,470 |
cpp
|
#include "SoundManager.h"
#include "AudioEngine.h"
using namespace cocos2d::experimental;
/*
* Staic variables
*/
SoundManager* SoundManager::m_sharedInstance = nullptr;
/*
* SoundManager
*/
SoundManager::SoundManager():
m_SoundEnabled(true),
m_MusicEnabled(true),
m_CurrentMusicId(AudioEngine::INVAILD_AUDIO_ID),
m_LoopMusic(true),
m_Volume(1.0f)
{
}
SoundManager* SoundManager::getInstance()
{
if (!m_sharedInstance)
{
m_sharedInstance = new (std::nothrow)SoundManager();
if (m_sharedInstance && m_sharedInstance->init())
{
}
else
{
CC_SAFE_DELETE(m_sharedInstance);
}
}
//
return m_sharedInstance;
}
void SoundManager::destroyInstance()
{
CC_SAFE_DELETE(m_sharedInstance);
}
bool SoundManager::init()
{
//SimpleAudioEngine::getInstance()->
return true;
}
void SoundManager::playSound(const std::string sound)
{
if (sound == "" || !m_SoundEnabled)
{
return;
}
std::string soundpath = (sound);
if (soundpath != "")
{
AudioProfile profile;
profile.name = "BackgroundMusic";
profile.maxInstances = 20;
AudioEngine::play2d(soundpath,false,m_Volume,&profile);
}
}
void SoundManager::playMusic(const std::string music)
{
if (music == "")
{
return;
}
SoundManager::stopMusic();
if (!m_MusicEnabled)
{
return;
}
std::string musicpath = (music);
if ( musicpath != "")
{
AudioProfile profile;
profile.name = "BackgroundMusic";
profile.maxInstances = 20;
m_CurrentMusicId = AudioEngine::play2d(musicpath,m_LoopMusic,m_Volume,&profile);
}
}
void SoundManager::pauseMusic()
{
if (m_CurrentMusicId != AudioEngine::INVAILD_AUDIO_ID)
{
AudioEngine::pause(m_CurrentMusicId);
}
}
void SoundManager::resumeMusic()
{
if (m_CurrentMusicId == AudioEngine::INVAILD_AUDIO_ID || !m_MusicEnabled)
{
return;
}
if(AudioEngine::getState(m_CurrentMusicId) == AudioEngine::AudioState::PAUSED)
{
AudioEngine::resume(m_CurrentMusicId);
}
}
void SoundManager::stopMusic()
{
AudioEngine::stop(m_CurrentMusicId);
m_CurrentMusicId = AudioEngine::INVAILD_AUDIO_ID;
}
void SoundManager::enableMusic(bool enabled)
{
m_MusicEnabled = enabled;
/*UserDefault::getInstance()->setBoolForKey(STT_MUSICENABLED,m_MusicEnabled);
UserDefault::getInstance()->flush();*/
}
void SoundManager::enableSound(bool enabled)
{
m_SoundEnabled = enabled;
/*UserDefault::getInstance()->setBoolForKey(STT_SOUNDENABLED,m_SoundEnabled);
UserDefault::getInstance()->flush();*/
}
|
[
"[email protected]"
] | |
4c04413634d44e5a608ab1e72fc4bec0b05fa4ed
|
906e77c7ff16e8a5ffb67995f247ded73a69dd59
|
/Cpp/SDK/GeometryCacheTracks_classes.h
|
16ac33020630dc144a5ade7f496cc45a2d8d93e9
|
[] |
no_license
|
zH4x-SDK/zPolygon-SDK
|
d49400829f1d4b7ec63ff6bebd790dd8d96bb8eb
|
3ff60c347b015d858779b8fd2308239176f1ed01
|
refs/heads/main
| 2023-07-25T12:16:54.962926 | 2021-08-27T14:17:29 | 2021-08-27T14:17:29 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,651 |
h
|
#pragma once
// Name: Polygon, Version: 0.3.13.76
/*!!DEFINE!!*/
/*!!HELPER_DEF!!*/
/*!!HELPER_INC!!*/
#ifdef _MSC_VER
#pragma pack(push, 0x01)
#endif
namespace CG
{
//---------------------------------------------------------------------------
// Classes
//---------------------------------------------------------------------------
// Class GeometryCacheTracks.MovieSceneGeometryCacheSection
// 0x0040 (FullSize[0x0128] - InheritedSize[0x00E8])
class UMovieSceneGeometryCacheSection : public UMovieSceneSection
{
public:
struct FMovieSceneGeometryCacheParams Params; // 0x00E8(0x0040) (Edit, NativeAccessSpecifierPublic)
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("Class GeometryCacheTracks.MovieSceneGeometryCacheSection");
return ptr;
}
};
// Class GeometryCacheTracks.MovieSceneGeometryCacheTrack
// 0x0018 (FullSize[0x0090] - InheritedSize[0x0078])
class UMovieSceneGeometryCacheTrack : public UMovieSceneNameableTrack
{
public:
unsigned char UnknownData_E1T1[0x8]; // 0x0078(0x0008) MISSED OFFSET (FIX SPACE BETWEEN PREVIOUS PROPERTY)
TArray<class UMovieSceneSection*> AnimationSections; // 0x0080(0x0010) (ExportObject, ZeroConstructor, ContainsInstancedReference, NativeAccessSpecifierPrivate)
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("Class GeometryCacheTracks.MovieSceneGeometryCacheTrack");
return ptr;
}
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
|
[
"[email protected]"
] | |
7a71b1fea711425586112ba9c62a433c8ef6846d
|
184a88de5fdf30388730e85961881e603bc9fea3
|
/VP/VPFramework/View/SCompilerResults/SCompilerResults.h
|
27d6e1709b23e59ee51ed5a59e4718eda21607da
|
[
"Apache-2.0"
] |
permissive
|
372507038/QtBlueprint
|
cf728cb37a78e7dc3afe23133d1db63ef48a76ba
|
6f948bcb170b0d921fff4a895f38edb668b5c52b
|
refs/heads/master
| 2022-11-20T13:37:41.898853 | 2020-07-16T03:11:36 | 2020-07-16T03:11:36 | 291,607,152 | 1 | 0 |
Apache-2.0
| 2020-08-31T03:42:38 | 2020-08-31T03:42:37 | null |
WINDOWS-1252
|
C++
| false | false | 421 |
h
|
/*************************************************
Copyright:Ver1.0
Author:zxf
Date:2020-06-16
Description:À¶Í¼±àÒë½á¹û
**************************************************/
#pragma once
#include <QWidget>
#include "ui_SCompilerResults.h"
class SCompilerResults : public QWidget
{
Q_OBJECT
public:
SCompilerResults(QWidget *parent = Q_NULLPTR);
~SCompilerResults();
private:
Ui::SCompilerResults ui;
};
|
[
"[email protected]"
] | |
7c67932ec3dd3f28eeaedda40f228b092da9dbc0
|
d042986a454921e46c5678524f561a8bd1ddbc72
|
/Data structure/week4/hash_substring.cpp
|
993c0ee731a1771909af68caa4df1dc04bd1e6fd
|
[] |
no_license
|
Abdullah-A-Elsayed/Coursera-Assignments
|
941210448fa4b0cbd7358591b7f701d5181ae104
|
7127d61443b2b82f2bea507545e5c2058ee5f3ec
|
refs/heads/master
| 2020-03-17T14:04:35.631619 | 2018-05-16T11:58:55 | 2018-05-16T11:58:55 | 133,657,045 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,961 |
cpp
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
struct Data {
string pattern, text;
};
ull hash_str(string s){//let x = 263, p 1000000007, no m, so card=p
ull hash=0;
for(int i=s.length()-1; i>-1; i--)
hash = ((hash*263)+ s[i] )%1000000007;
return hash;
}
Data read_input() {
Data data;
cin >> data.pattern >> data.text;
return data;
}
void print_occurrences(const vector<int>& output) {
for (int i = output.size()-1; i >-1; --i)
cout << output[i] << " ";
cout << "\n";
}
vector<int> get_occurrences_naive(const Data& input) {
const string& s = input.pattern, t = input.text;
vector<int> ans;
for (size_t i = 0; i + s.size() <= t.size(); ++i)
if (t.substr(i, s.size()) == s)
ans.push_back(i);
return ans;
}
vector<int> get_occurrences(const Data& input) {
const string& s = input.pattern, t = input.text;
vector<int> ans;
ull s_hash = hash_str(s);
ull T_hash = hash_str(t.substr(t.length()-s.length()));
//h(i) = h(i+1)x+ int(t(i)) - x^p * int(t(i+|p|))
//x^p
ull p =1000000007;
int x = 263;
ull x_to_p = x;
for(int i=0; i<s.length()-1; ++i) x_to_p= (x_to_p * x) %p;
//cout<<"x^p = "<<x_to_p<<endl;
//cout<<t.substr(t.length()-s.length())<<" hash: "<<T_hash<<endl;
for (int i = t.length()-s.length(); i>-1 ; --i){
if(s_hash == T_hash){
if (t.substr(i, s.size()) == s)
ans.push_back(i);
}
//cout<<t.substr(i, s.size())<<" hash1: "<<hash_str(t.substr(i, s.size()))<<endl;
//cout<<t.substr(i, s.size())<<" hash2: "<<T_hash<<endl<<endl;
if(i!=0){
T_hash =( (T_hash * x) + t[i-1] - (x_to_p * t[i-1+s.size()])%p +p ) %p;
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false);
print_occurrences(get_occurrences(read_input()));
return 0;
}
|
[
"[email protected]"
] | |
43c6029b647f5c0ed5ad0e170e301e13838a58f4
|
c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64
|
/Engine/Source/Editor/MeshPaint/Public/MeshPaintModule.h
|
91b1464e2870adbef3ee6a1ca57c0c474086e85e
|
[
"MIT",
"LicenseRef-scancode-proprietary-license"
] |
permissive
|
windystrife/UnrealEngine_NVIDIAGameWorks
|
c3c7863083653caf1bc67d3ef104fb4b9f302e2a
|
b50e6338a7c5b26374d66306ebc7807541ff815e
|
refs/heads/4.18-GameWorks
| 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 |
MIT
| 2022-12-16T05:36:38 | 2018-03-06T15:44:09 |
C++
|
UTF-8
|
C++
| false | false | 491 |
h
|
// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "Modules/ModuleInterface.h"
class IMeshPaintGeometryAdapterFactory;
/**
* MeshPaint module interface
*/
class IMeshPaintModule : public IModuleInterface
{
public:
virtual void RegisterGeometryAdapterFactory(TSharedRef<IMeshPaintGeometryAdapterFactory> Factory) = 0;
virtual void UnregisterGeometryAdapterFactory(TSharedRef<IMeshPaintGeometryAdapterFactory> Factory) = 0;
};
|
[
"[email protected]"
] | |
d67ee1119e51a1eaf3aa290c78a6db3cfcbb14c2
|
8c7591fcf16e64564ab18a0d762e0402dff30194
|
/aiko/systems/entity/light.hpp
|
c16e2f389ded97e58daf84f6ceb620b22694ba7c
|
[
"BSD-2-Clause"
] |
permissive
|
jotask/AikoEngineTest
|
b40f4bfbbbf51426dbdbb60c8d5de5ade42bf774
|
01a237515194549259dd658d0cda08b9a0243783
|
refs/heads/master
| 2020-11-28T07:08:48.944024 | 2019-12-26T16:57:53 | 2019-12-26T16:57:53 | 229,738,737 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 473 |
hpp
|
#pragma once
#include "shared/transform.hpp"
#include "glm.hpp"
namespace aiko
{
class Light
{
public:
using Color = glm::vec3;
Light();
virtual ~Light() = default;
Transform& getTranform();
void randomise();
Color& getColor();
void updateLight();
private:
Transform m_transform;
float m_radius;
float m_fov;
Color m_color;
};
}
|
[
"[email protected]"
] | |
1ecf75c45fad6671138313821826e6a35b93657a
|
300f601e3cb51dc85b61347e2350464e6f4def1a
|
/379a.cpp
|
00b3bc0f1403c212676581b5339e0bad3ab1928d
|
[] |
no_license
|
websopon24/19701073_Md_Sopon_Abdullah
|
dc60d03e2c7a624beddca5e86001ff1de03e2755
|
57a85a3600ad4c8bc08595a34f495f6bcb3f59d6
|
refs/heads/main
| 2023-08-25T12:25:17.379063 | 2021-10-27T12:45:12 | 2021-10-27T12:45:12 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 222 |
cpp
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b;
cin>>a>>b;
int c=0,x=0,h=a;
while(a>=b)
{
x=a%b;
a=a/b;
h+=a;
a=a+x;
}
cout<<h<<endl;
return 0; }
|
[
"[email protected]"
] | |
1dfa4fe10f5ff5888864d69a35e608596f045237
|
460455e7990de7257aa223a58e73069f3ef7ff43
|
/src/server/game/BattlePet/BattlePet.cpp
|
143f7be2d3bde9bb122c78b206a4154818418b8d
|
[] |
no_license
|
Shkipper/wmane
|
2ce69adea1eedf866921c857cbc5bd1bc6d037f0
|
2da37e1e758f17b61efb6aae8fa7343b234f3dcd
|
refs/heads/master
| 2020-04-24T19:51:51.897587 | 2019-02-25T06:14:18 | 2019-02-25T06:14:18 | 172,225,859 | 0 | 0 | null | 2019-02-23T14:49:31 | 2019-02-23T14:49:31 | null |
UTF-8
|
C++
| false | false | 50,294 |
cpp
|
/*
* Copyright (C) 2015 Warmane <http://www.warmane.com/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "AchievementMgr.h"
#include "BattlePet.h"
#include "BattlePetAbilityEffect.h"
#include "BattlePetSpawnMgr.h"
#include "DBCStores.h"
#include "DB2Enums.h"
#include "DB2Stores.h"
#include "ObjectAccessor.h"
#include "ObjectMgr.h"
#include "Player.h"
#include "SharedDefines.h"
#include "Util.h"
#include "WorldSession.h"
#include <algorithm>
// -------------------------------------------------------------------------------
// Battle Pet
// -------------------------------------------------------------------------------
void BattlePet::Initialise(bool newBattlePet)
{
memset(AbilitiyIds, 0, sizeof(AbilitiyIds));
// existence is checked before this, no problem should arise
m_npc = sBattlePetSpeciesStore.LookupEntry(m_species)->NpcId;
m_displayId = sObjectMgr->GetCreatureTemplate(m_npc)->Modelid1;
// setup initial battle pet states
InitialiseStates(newBattlePet);
}
void BattlePet::InitialiseStates(bool newBattlePet)
{
// initialise states
memset(States, 0, sizeof(States));
memset(m_mainStates, 0, sizeof(m_mainStates));
States[BATTLE_PET_STATE_STAT_CRITICAL_CHANCE] = 5;
States[BATTLE_PET_STATE_MOD_PET_TYPE_ID] = m_family;
// set passive ability states
static const uint32 familtyPassiveStates[BATTLE_PET_FAMILY_COUNT] =
{
BATTLE_PET_STATE_PASSIVE_HUMANOID,
BATTLE_PET_STATE_PASSIVE_DRAGON,
BATTLE_PET_STATE_PASSIVE_FLYING,
BATTLE_PET_STATE_PASSIVE_UNDEAD,
BATTLE_PET_STATE_PASSIVE_CRITTER,
BATTLE_PET_STATE_PASSIVE_MAGIC,
BATTLE_PET_STATE_PASSIVE_ELEMENTAL,
BATTLE_PET_STATE_PASSIVE_BEAST,
BATTLE_PET_STATE_PASSIVE_AQUATIC,
BATTLE_PET_STATE_PASSIVE_MECHANICAL,
};
States[familtyPassiveStates[m_family]] = 1;
// set breed specific states
for (uint32 i = 0; i < sBattlePetBreedStateStore.GetNumRows(); i++)
{
auto breedStateEntry = sBattlePetBreedStateStore.LookupEntry(i);
if (!breedStateEntry)
continue;
if (breedStateEntry->BreedId != m_breed)
continue;
// handle main stat states
if (IsMainStatState(breedStateEntry->StateId))
m_mainStates[breedStateEntry->StateId - BATTLE_PET_STATE_STAT_POWER] += breedStateEntry->Modifier;
// other states
else
States[breedStateEntry->StateId] += breedStateEntry->Modifier;
}
// set species specific states
for (uint32 i = 0; i < sBattlePetSpeciesStateStore.GetNumRows(); i++)
{
auto speciesStateEntry = sBattlePetSpeciesStateStore.LookupEntry(i);
if (!speciesStateEntry)
continue;
if (speciesStateEntry->SpeciesId != m_species)
continue;
// handle main stat states
if (IsMainStatState(speciesStateEntry->StateId))
m_mainStates[speciesStateEntry->StateId - BATTLE_PET_STATE_STAT_POWER] += speciesStateEntry->Modifier;
else
// other states
States[speciesStateEntry->StateId] += speciesStateEntry->Modifier;
}
// apply quality modifier
for (uint8 i = 0; i < BATTLE_PET_MAX_MAIN_STATES; i++)
{
auto breedQualityEntry = sBattlePetBreedQualityStore.LookupEntry(7 + m_quality);
ASSERT(breedQualityEntry);
m_mainStates[i] *= breedQualityEntry->Multiplier;
}
// calculate main stats
CalculateStats(newBattlePet);
if (!m_curHealth)
States[BATTLE_PET_STATE_IS_DEAD] = 1;
}
void BattlePet::InitialiseAbilities(bool wild)
{
// calculate abilites for the battle pet
for (uint32 i = 0; i < sBattlePetSpeciesXAbilityStore.GetNumRows(); i++)
{
auto abilityEntry = sBattlePetSpeciesXAbilityStore.LookupEntry(i);
if (!abilityEntry)
continue;
if (abilityEntry->SpeciesId != m_species)
continue;
if (abilityEntry->RequiredLevel > m_level)
continue;
// first ability in the tier
if (abilityEntry->RequiredLevel < 5)
AbilitiyIds[abilityEntry->SlotId] = abilityEntry->AbilityId;
// second ability in the tier
else
{
// wild battle pets have their second ability decided by chance
if (wild && urand(0, 1))
AbilitiyIds[abilityEntry->SlotId] = abilityEntry->AbilityId;
// player battle pets have their second ability decided by journal flags
else if (!wild)
{
switch (abilityEntry->SlotId)
{
case 0:
if (HasFlag(BATTLE_PET_JOURNAL_FLAG_ABILITY_1))
AbilitiyIds[abilityEntry->SlotId] = abilityEntry->AbilityId;
break;
case 1:
if (HasFlag(BATTLE_PET_JOURNAL_FLAG_ABILITY_2))
AbilitiyIds[abilityEntry->SlotId] = abilityEntry->AbilityId;
break;
case 2:
if (HasFlag(BATTLE_PET_JOURNAL_FLAG_ABILITY_3))
AbilitiyIds[abilityEntry->SlotId] = abilityEntry->AbilityId;
break;
}
}
}
}
}
void BattlePet::SetBattleAbilities()
{
// initialise abilities for battle
for (uint8 i = 0; i < BATTLE_PET_MAX_ABILITIES; i++)
{
if (!AbilitiyIds[i])
{
Abilities[i] = nullptr;
continue;
}
auto battlePetAbility = new BattlePetAbility();
battlePetAbility->AbilityId = AbilitiyIds[i];
battlePetAbility->OnCooldown = false;
battlePetAbility->Cooldown = 0;
battlePetAbility->Lockdown = 0;
Abilities[i] = battlePetAbility;
}
}
void BattlePet::CalculateStats(bool currentHealth)
{
// initial values
for (uint8 i = 0; i < BATTLE_PET_MAX_MAIN_STATES; i++)
States[BATTLE_PET_STATE_STAT_POWER + i] = m_mainStates[i];
// apply level modifier
States[BATTLE_PET_STATE_STAT_POWER] *= m_level;
States[BATTLE_PET_STATE_STAT_SPEED] *= m_level;
// calculate health
m_maxHealth = (10000 + (States[BATTLE_PET_STATE_STAT_STAMINA] * 5) * m_level) / 100;
if (currentHealth)
m_curHealth = m_maxHealth;
// flag battle pet for save
m_dbState = BATTLE_PET_DB_STATE_SAVE;
}
void BattlePet::SetFlag(uint16 flag)
{
if (HasFlag(flag))
return;
m_flags |= flag;
m_dbState = BATTLE_PET_DB_STATE_SAVE;
}
void BattlePet::UnSetFlag(uint16 flag)
{
if (!HasFlag(flag))
return;
m_flags &= ~flag;
m_dbState = BATTLE_PET_DB_STATE_SAVE;
}
void BattlePet::SetCurrentHealth(uint32 health)
{
if (health > m_maxHealth)
health = m_maxHealth;
if (!IsAlive() && health)
States[BATTLE_PET_STATE_IS_DEAD] = 0;
m_curHealth = health;
m_dbState = BATTLE_PET_DB_STATE_SAVE;
}
void BattlePet::SetNickname(std::string nickname)
{
m_nickname = nickname;
m_dbState = BATTLE_PET_DB_STATE_SAVE;
}
void BattlePet::SetXP(uint16 xpGain)
{
if (!xpGain)
return;
if (m_level == BATTLE_PET_MAX_LEVEL)
return;
uint16 baseValue = sGtBattlePetXpStore.LookupEntry(100 + (m_level - 1))->Value;
uint16 multiplier = sGtBattlePetXpStore.LookupEntry(m_level - 1)->Value;
uint16 maxXpForLevel = baseValue * multiplier;
// battle pet has leveled
if (m_xp + xpGain >= maxXpForLevel)
{
m_xp = (m_xp + xpGain) - maxXpForLevel;
SetLevel(m_level + 1);
}
else
m_xp += xpGain;
m_dbState = BATTLE_PET_DB_STATE_SAVE;
}
void BattlePet::SetLevel(uint8 level)
{
// make sure level is valid
if (!level || level > BATTLE_PET_MAX_LEVEL || level == m_level)
return;
if (m_level == BATTLE_PET_MAX_LEVEL || level < m_level)
m_xp = 0;
m_level = level;
// These achievements should be handled better?
// Achievement: Newbie - Raise a pet to level 3.
if (m_level >= 3 && !m_owner->GetAchievementMgr().HasAchieved(BATTLE_PET_ACHIEVEMENT_NEWBIE))
{
auto achievement = sAchievementMgr->GetAchievement(BATTLE_PET_ACHIEVEMENT_NEWBIE);
m_owner->CompletedAchievement(achievement);
// unlock second loadout slot
m_owner->GetBattlePetMgr().UnlockLoadoutSlot(BATTLE_PET_LOADOUT_SLOT_2);
}
// Achievement: Just a Pup - Raise a pet to level 5.
if (m_level >= 5 && !m_owner->GetAchievementMgr().HasAchieved(BATTLE_PET_ACHIEVEMENT_JUST_A_PUP))
{
auto achievement = sAchievementMgr->GetAchievement(BATTLE_PET_ACHIEVEMENT_JUST_A_PUP);
m_owner->CompletedAchievement(achievement);
// unlock third loadout slot
m_owner->GetBattlePetMgr().UnlockLoadoutSlot(BATTLE_PET_LOADOUT_SLOT_3);
}
CalculateStats(true);
InitialiseAbilities(false);
// update world object if battle pet is currently summoned
if (m_owner->GetBattlePetMgr().GetCurrentSummonId() == m_id)
{
auto worldPet = m_owner->GetBattlePetMgr().GetCurrentSummon();
worldPet->SetUInt32Value(UNIT_FIELD_WILD_BATTLE_PET_LEVEL, m_level);
worldPet->SetHealth(m_curHealth);
worldPet->SetMaxHealth(m_maxHealth);
}
}
uint16 BattlePet::GetSpeed() const
{
int32 modPercent = States[BATTLE_PET_STATE_MOD_SPEED_PERCENT];
// Flying (239)
// Flying creatures gain 50% extra speed while above 50% health
if (States[BATTLE_PET_STATE_PASSIVE_FLYING])
if ((GetCurrentHealth() * 100 / GetMaxHealth()) > 50)
modPercent += 50;
return (States[BATTLE_PET_STATE_STAT_SPEED] + CalculatePct(States[BATTLE_PET_STATE_STAT_SPEED], modPercent)) / 100;
}
uint16 BattlePet::GetPower() const
{
return (States[BATTLE_PET_STATE_STAT_POWER] + CalculatePct(States[BATTLE_PET_STATE_STAT_POWER], States[BATTLE_PET_STATE_MOD_DAMAGE_DEALT_PCT])) / 100;
}
void BattlePet::ResetMechanicStates()
{
States[BATTLE_PET_STATE_MECHANIC_POISONED] = 0;
States[BATTLE_PET_STATE_MECHANIC_STUNNED] = 0;
States[BATTLE_PET_STATE_MOD_SPEED_PERCENT] = 0;
States[BATTLE_PET_STATE_UNTARGETABLE] = 0;
States[BATTLE_PET_STATE_UNDERGROUND] = 0;
States[BATTLE_PET_STATE_MECHANIC_FLYING] = 0;
States[BATTLE_PET_STATE_MECHANIC_BURNING] = 0;
States[BATTLE_PET_STATE_TURN_LOCK] = 0;
States[BATTLE_PET_STATE_SWAP_OUT_LOCK] = 0;
States[BATTLE_PET_STATE_MECHANIC_CHILLED] = 0;
States[BATTLE_PET_STATE_MECHANIC_WEBBED] = 0;
States[BATTLE_PET_STATE_MECHANIC_INVISIBLE] = 0;
States[BATTLE_PET_STATE_UNKILLABLE] = 0;
States[BATTLE_PET_STATE_MECHANIC_BLEEDING] = 0;
States[BATTLE_PET_STATE_MECHANIC_BLIND] = 0;
States[BATTLE_PET_STATE_SWAP_IN_LOCK] = 0;
States[BATTLE_PET_STATE_MECHANIC_BOMB] = 0;
States[BATTLE_PET_STATE_RESILITANT] = 0;
}
PetBattleAura* BattlePet::GetAura(uint32 abilityId)
{
for (auto &aura : Auras)
if (aura->GetAbility() == abilityId && !aura->HasExpired())
return aura;
return nullptr;
}
// -------------------------------------------------------------------------------
// Pet Battle
// -------------------------------------------------------------------------------
void PetBattleAura::OnApply()
{
// apply any state modifiers for the aura
for (uint32 i = 0; i < sBattlePetAbilityStateStore.GetNumRows(); i++)
{
auto stateEntry = sBattlePetAbilityStateStore.LookupEntry(i);
if (!stateEntry)
continue;
if (stateEntry->AbilityId != m_ability)
continue;
// store state and modifier for removal
if (m_auraStates.find(stateEntry->StateId) == m_auraStates.end())
m_auraStates[stateEntry->StateId] = 0;
int32 newValue = stateEntry->Value + m_target->States[stateEntry->StateId];
m_auraStates[stateEntry->StateId] += newValue;
// update state
m_petBattle->UpdatePetState(m_caster, m_target, 0, stateEntry->StateId, newValue);
}
}
void PetBattleAura::OnExpire()
{
// remove any state modifiers for the aura
for (auto stateEntry : m_auraStates)
{
int32 newValue = m_target->States[stateEntry.first] - stateEntry.second;
m_petBattle->UpdatePetState(m_caster, m_target, 0, stateEntry.first, newValue);
}
m_auraStates.clear();
}
void PetBattleAura::Process()
{
// expire aura if it has reached max duration
if (m_duration != -1 && m_turn > m_maxDuration && !m_expired)
{
Expire();
return;
}
// handle aura effects
if (auto abilityEntry = sBattlePetAbilityStore.LookupEntry(m_ability))
{
uint32 turnCount = 0;
uint32 topMaxTurnId = 0;
// find longest duration effect
for (uint32 i = 0; i < sBattlePetAbilityTurnStore.GetNumRows(); i++)
{
auto abilityTurnEntry = sBattlePetAbilityTurnStore.LookupEntry(i);
if (!abilityTurnEntry || abilityTurnEntry->AbilityId != m_ability)
continue;
turnCount++;
topMaxTurnId = std::max(topMaxTurnId, abilityTurnEntry->Duration);
}
for (uint32 i = 0; i < sBattlePetAbilityTurnStore.GetNumRows(); i++)
{
// make sure ability turn entry is for auras ability
auto abilityTurnEntry = sBattlePetAbilityTurnStore.LookupEntry(i);
if (!abilityTurnEntry || abilityTurnEntry->AbilityId != m_ability)
continue;
// make sure ability has reached duration required for effect
if (abilityTurnEntry->Duration != m_turn && turnCount != 1 && topMaxTurnId != 1)
continue;
for (uint32 j = 0; j < sBattlePetAbilityEffectStore.GetNumRows(); j++)
{
auto abilityEffectEntry = sBattlePetAbilityEffectStore.LookupEntry(j);
if (!abilityEffectEntry || abilityEffectEntry->AbilityTurnId != abilityTurnEntry->Id)
continue;
// initialise ability effect
BattlePetAbilityEffect abilityEffect;
abilityEffect.SetAbilityInfo(m_ability, abilityEffectEntry, abilityEntry->FamilyId);
abilityEffect.SetCaster(m_caster);
abilityEffect.AddTarget(m_target);
abilityEffect.SetParentBattle(m_petBattle);
abilityEffect.Execute();
}
}
}
// notify client of aura update
PetBattleEffect effect(PET_BATTLE_EFFECT_AURA_CHANGE, m_caster->GetGlobalIndex());
effect.TargetUpdateAura(m_target->GetGlobalIndex(), m_id, m_ability, m_duration, m_turn);
m_petBattle->Effects.push_back(effect);
m_turn++;
if (m_duration != -1)
m_duration--;
}
void PetBattleAura::Expire()
{
if (m_expired)
return;
m_expired = true;
// notify client of aura removal
PetBattleEffect effect(PET_BATTLE_EFFECT_AURA_REMOVE, m_caster->GetGlobalIndex(), 0, 0, 1, 0, 1);
effect.TargetUpdateAura(m_target->GetGlobalIndex(), m_id, m_ability, 0, 0);
m_petBattle->Effects.push_back(effect);
// cast any removal procs the ability might have
m_petBattle->Cast(m_target, m_ability, m_turn, PET_BATTLE_ABILITY_TURN0_PROC_ON_AURA_REMOVED);
OnExpire();
}
// -------------------------------------------------------------------------------
void PetBattleTeam::AddPlayer(Player* player)
{
m_owner = player;
m_ownerGuid = player->GetGUID();
// add player loadout battle pets to team
uint8 localIndex = 0;
for (uint8 i = 0; i < BATTLE_PET_MAX_LOADOUT_SLOTS; i++)
{
uint64 battlePetId = player->GetBattlePetMgr().GetLoadoutSlot(i);
if (!battlePetId)
continue;
auto battlePet = player->GetBattlePetMgr().GetBattlePet(battlePetId);
if (!battlePet->IsAlive())
continue;
// bind pet battle information to battle pet
battlePet->SetBattleInfo(m_teamIndex, ConvertToGlobalIndex(localIndex++));
battlePet->SetBattleAbilities();
// in PvE matches, the first pet in loadout is initially set to active pet
if (m_petBattle->GetType() == PET_BATTLE_TYPE_PVE && !m_activePet)
m_activePet = battlePet;
BattlePets.push_back(battlePet);
}
}
void PetBattleTeam::AddWildBattlePet(Creature* creature)
{
auto battlePet = sBattlePetSpawnMgr->GetWildBattlePet(creature);
ASSERT(battlePet);
battlePet->SetBattleInfo(m_teamIndex, ConvertToGlobalIndex(BattlePets.size()));
battlePet->SetBattleAbilities();
BattlePets.push_back(battlePet);
// only update creature if it's the first to the team
if (!m_wildBattlePet)
{
m_wildBattlePet = creature;
m_activePet = battlePet;
}
}
typedef std::vector<uint32> AvaliableAbilities;
void PetBattleTeam::Update()
{
if (m_ready)
return;
if (!m_activePet->IsAlive())
{
BattlePetStore avaliablePets;
GetAvaliablePets(avaliablePets);
// team is dead, finish battle
if (!avaliablePets.size())
{
m_petBattle->FinishBattle(this, false);
return;
}
// final pet, auto swap
if (avaliablePets.size() == 1)
m_petBattle->SwapActivePet(avaliablePets[0]);
}
else
{
// team has no move if multiple turn ability active
if (HasMultipleTurnAbility())
{
m_ready = true;
return;
}
// wild battle pets currently choose a random ability that isn't on cooldown, no other AI
if (m_petBattle->GetType() == PET_BATTLE_TYPE_PVE && m_teamIndex == PET_BATTLE_OPPONENT_TEAM)
{
AvaliableAbilities avaliableAbilities;
for (uint8 i = 0; i < BATTLE_PET_MAX_ABILITIES; i++)
if (m_activePet->Abilities[i])
if (CanActivePetCast(m_activePet->Abilities[i]->AbilityId))
avaliableAbilities.push_back(m_activePet->Abilities[i]->AbilityId);
// cast ability
if (avaliableAbilities.size())
SetPendingMove(PET_BATTLE_MOVE_TYPE_CAST, avaliableAbilities[rand() % avaliableAbilities.size()], nullptr);
// skip turn
else
SetPendingMove(PET_BATTLE_MOVE_TYPE_SWAP_OR_PASS, 0, m_activePet);
}
}
}
void PetBattleTeam::ActivePetPrepareCast(uint32 abilityId)
{
if (!abilityId)
return;
// find the longest duration effect for ability
uint8 duration = 0;
for (uint32 i = 0; i < sBattlePetAbilityStore.GetNumRows(); i++)
{
auto abilityTurnEntry = sBattlePetAbilityTurnStore.LookupEntry(i);
if (!abilityTurnEntry || abilityTurnEntry->AbilityId != abilityId)
continue;
if (abilityTurnEntry->Duration >= duration)
duration = abilityTurnEntry->Duration;
}
ActiveAbility.AbilityId = abilityId;
ActiveAbility.TurnsPassed = 1;
ActiveAbility.TurnsTotal = duration;
}
bool PetBattleTeam::CanActivePetCast(uint32 abilityId) const
{
if (HasMultipleTurnAbility())
return false;
if (!sBattlePetAbilityStore.LookupEntry(abilityId))
return false;
// make sure active pet has ability and it isn't on cooldown
for (uint8 i = 0; i < BATTLE_PET_MAX_ABILITIES; i++)
if (m_activePet->Abilities[i] && m_activePet->Abilities[i]->AbilityId == abilityId && !m_activePet->Abilities[i]->OnCooldown)
return true;
return false;
}
uint8 PetBattleTeam::GetTrapStatus() const
{
if (m_petBattle->GetType() != PET_BATTLE_TYPE_PVE)
return PET_BATTLE_TRAP_STATUS_NOT_CAPTURABLE;
if (m_teamIndex == PET_BATTLE_OPPONENT_TEAM)
return PET_BATTLE_TRAP_STATUS_DISABLED;
auto &battlePetMgr = m_owner->GetBattlePetMgr();
// player needs to have a trap ability
if (!battlePetMgr.GetTrapAbility())
return PET_BATTLE_TRAP_STATUS_DISABLED;
// player can only catch a single pet per battle
if (m_petBattle->GetCagedPet())
return PET_BATTLE_TRAP_STATUS_ALREADY_TRAPPED;
auto team = m_petBattle->Teams[PET_BATTLE_OPPONENT_TEAM];
if (!team->GetActivePet()->IsAlive())
return PET_BATTLE_TRAP_STATUS_CANT_TRAP_DEAD_PET;
// make sure player can store more battle pets
if (!battlePetMgr.CanStoreBattlePet(team->GetActivePet()->GetSpecies()))
return PET_BATTLE_TRAP_STATUS_TOO_MANY_PETs;
// check if pet is below 35% health
if (team->GetActivePet()->GetCurrentHealth() > CalculatePct(team->GetActivePet()->GetMaxHealth(), 35))
return PET_BATTLE_TRAP_STATUS_HEALTH_TOO_HIGH;
return PET_BATTLE_TRAP_STATUS_ENABLED;
}
bool PetBattleTeam::CanSwap(BattlePet* battlePet, bool ignoreAlive) const
{
if (HasMultipleTurnAbility())
return false;
if (!m_activePet->IsAlive() && !ignoreAlive)
return false;
// used for abilities such as Sticky Web (339)
if (m_activePet->States[BATTLE_PET_STATE_SWAP_OUT_LOCK])
return false;
if (battlePet)
{
if (!battlePet->IsAlive())
return false;
// used for abilities such as Banished (717)
if (battlePet->States[BATTLE_PET_STATE_SWAP_IN_LOCK])
return false;
}
return true;
}
bool PetBattleTeam::HasMultipleTurnAbility() const
{
if (ActiveAbility.AbilityId && ActiveAbility.TurnsTotal != 1 && ActiveAbility.TurnsPassed <= ActiveAbility.TurnsTotal)
return true;
return false;
}
void PetBattleTeam::DoCasts(int8 procType)
{
if (!m_activePet->IsAlive())
return;
if (!m_activePet->CanAttack())
return;
bool noProc = procType == PET_BATTLE_ABILITY_TURN0_PROC_ON_NONE;
m_petBattle->Cast(m_activePet, ActiveAbility.AbilityId, noProc ? ActiveAbility.TurnsPassed : 0, procType);
}
void PetBattleTeam::GetAvaliablePets(BattlePetStore &avaliablePets) const
{
for (auto battlePet : BattlePets)
{
if (!battlePet->IsAlive())
continue;
// make sure local pet can be swapped with active
if (!CanSwap(battlePet, true))
continue;
avaliablePets.push_back(battlePet);
}
}
// checks if a battle pet belongs to a pet battle team
bool PetBattleTeam::IsValidBattlePet(BattlePet* battlePet) const
{
bool isValid = false;
for (auto battlePetTeam : BattlePets)
if (battlePetTeam == battlePet)
isValid = true;
return isValid;
}
uint8 PetBattleTeam::GetInputStatusFlags() const
{
uint8 flags = PET_BATTLE_TEAM_INPUT_FLAG_NONE;
// TODO: more checks probably required
if (HasMultipleTurnAbility())
flags |= (PET_BATTLE_TEAM_INPUT_FLAG_LOCK_ABILITY_1 | PET_BATTLE_TEAM_INPUT_FLAG_LOCK_ABILITY_2);
if (!CanSwap())
flags |= PET_BATTLE_TEAM_INPUT_FLAG_LOCK_PET_SWAP;
if (!m_activePet->IsAlive())
{
BattlePetStore avaliablePets;
GetAvaliablePets(avaliablePets);
if (avaliablePets.size())
flags |= PET_BATTLE_TEAM_INPUT_FLAG_SELECT_NEW_PET;
else
flags |= PET_BATTLE_TEAM_INPUT_FLAG_LOCK_PET_SWAP;
}
return flags;
}
void PetBattleTeam::ResetActiveAbility()
{
ActiveAbility.AbilityId = 0;
ActiveAbility.TurnsPassed = 0;
ActiveAbility.TurnsTotal = 0;
}
void PetBattleTeam::ProcessAuras()
{
// process any active auras
for (auto battlePet : BattlePets)
{
for (auto aura : battlePet->Auras)
{
if (!aura->HasExpired())
aura->Process();
// 543 - Prowl
if (aura->GetAbility() == 543
&& aura->GetTurn() > 2
&& m_activePet->States[BATTLE_PET_STATE_CONDITION_DID_DAMAGE_THIS_ROUND])
aura->Expire();
// remove next attack auras (Attack Reduction)
if (aura->GetDuration() == -1
&& aura->GetTurn() > 2
&& m_activePet->States[BATTLE_PET_STATE_CONDITION_DID_DAMAGE_THIS_ROUND])
aura->Expire();
}
}
}
typedef std::vector<PetBattleAura*> AuraRemovalStore;
void PetBattleTeam::RemoveExpiredAuras()
{
// find any expired auras that need removing
AuraRemovalStore removalList;
for (auto battlePet : BattlePets)
{
for (auto &aura : battlePet->Auras)
if (aura->HasExpired())
removalList.push_back(aura);
// delete expired auras
for (auto &aura : removalList)
{
battlePet->Auras.remove(aura);
delete aura;
}
removalList.clear();
}
}
void PetBattleTeam::SetPendingMove(uint8 moveType, uint32 abilityId, BattlePet* newActivePet)
{
m_pendingMove.MoveType = moveType;
m_pendingMove.AbilityId = abilityId;
m_pendingMove.battlePet = newActivePet;
m_ready = true;
}
// -------------------------------------------------------------------------------
uint8 PetBattleTeam::ConvertToGlobalIndex(uint8 localPetIndex) const
{
ASSERT(localPetIndex < PET_BATTLE_MAX_TEAM_PETS);
return localPetIndex + (m_teamIndex == PET_BATTLE_CHALLANGER_TEAM ? 0 : PET_BATTLE_MAX_TEAM_PETS);
}
uint8 PetBattleTeam::ConvertToLocalIndex(uint8 globalPetIndex) const
{
ASSERT(globalPetIndex < (PET_BATTLE_MAX_TEAM_PETS * PET_BATTLE_MAX_TEAMS));
return globalPetIndex - (m_teamIndex == PET_BATTLE_CHALLANGER_TEAM ? 0 : PET_BATTLE_MAX_TEAM_PETS);
}
// -------------------------------------------------------------------------------
PetBattle::~PetBattle()
{
// clean up teams
for (uint8 i = 0; i < PET_BATTLE_MAX_TEAMS; i++)
delete Teams[i];
}
void PetBattle::StartBattle()
{
// in PvE matches the initial active pet is locked
for (auto &team : Teams)
SwapActivePet(team->GetActivePet());
for (auto &team : Teams)
{
// initial team setup only required for players
if (team->GetTeamIndex() == PET_BATTLE_OPPONENT_TEAM && m_type == PET_BATTLE_TYPE_PVE)
continue;
auto owner = Teams[team->GetTeamIndex()]->GetOwner();
owner->GetBattlePetMgr().UnSummonCurrentBattlePet(true);
// send initial packet update
owner->GetSession()->SendPetBattleInitialUpdate(this);
owner->GetSession()->SendPetBattleFirstRound(this);
}
Effects.clear();
// round setup
m_phase = PET_BATTLE_PHASE_IN_PROGRESS;
m_round++;
}
void PetBattle::FinishBattle(PetBattleTeam* lostTeam, bool forfeit)
{
// if no winning team is specified, battle was forcefully ended
m_winningTeam = nullptr;
if (lostTeam)
m_winningTeam = Teams[!lostTeam->GetTeamIndex()];
for (auto team : Teams)
{
for (auto battlePet : team->BattlePets)
{
// remove abilities
for (uint8 i = 0; i < BATTLE_PET_MAX_ABILITIES; i++)
{
if (auto ability = battlePet->Abilities[i])
{
delete ability;
battlePet->Abilities[i] = nullptr;
}
}
// remove auras
for (auto &aura : battlePet->Auras)
{
aura->OnExpire();
delete aura;
}
battlePet->Auras.clear();
// remove any remaining mechanic states not cleaned up on aura removal
battlePet->ResetMechanicStates();
}
if (auto player = team->GetOwner())
{
for (auto battlePet : team->BattlePets)
{
// make sure battle wasn't forcefully ended
if (m_winningTeam)
{
// remove 10% health on forfeit
if (team != m_winningTeam && forfeit)
{
uint16 reduction = CalculatePct(battlePet->GetCurrentHealth(), 10);
battlePet->SetCurrentHealth(battlePet->GetCurrentHealth() - reduction);
}
// award XP to battle pets that actively participated in the battle
if (team->SeenAction.find(battlePet) != team->SeenAction.end()
&& GetType() == PET_BATTLE_TYPE_PVE
&& m_winningTeam == team
&& battlePet->GetLevel() != BATTLE_PET_MAX_LEVEL
&& battlePet->IsAlive())
{
// XP gain formular from: http://www.wowwiki.com/Pet_Battle_System#Calculating_experience
uint16 xp = 0;
for (auto opponentBattlePet : Teams[!team->GetTeamIndex()]->BattlePets)
{
int levelDifference = opponentBattlePet->GetLevel() - battlePet->GetLevel();
// level difference roof capped at +2
if (levelDifference > 2)
levelDifference = 2;
// level difference floor capped at -4
else if (levelDifference < -4)
levelDifference = -4;
xp += ((opponentBattlePet->GetLevel() + 9) * (levelDifference + 5)) / team->SeenAction.size();
}
battlePet->SetXP(xp);
}
// update battle pet clientside
player->GetBattlePetMgr().SendBattlePetUpdate(battlePet, false);
}
}
// make sure battle wasn't forcefully ended
if (m_winningTeam)
{
// save captured pets
if (m_winningTeam == team && GetType() == PET_BATTLE_TYPE_PVE)
{
if (auto battlePet = GetCagedPet())
{
auto &battlePetMgr = player->GetBattlePetMgr();
if (!battlePetMgr.CanStoreBattlePet(battlePet->GetSpecies()))
continue;
uint8 level = battlePet->GetLevel();
// level 16-20 pets lose 1 level when caught
if (level >= 16 && level <= 20)
level--;
// level 21-25 pets lose 2 levels when caught
else if (level >= 21 && level <= 25)
level -= 2;
battlePetMgr.Create(battlePet->GetSpecies(), level, battlePet->GetBreed(), battlePet->GetQuality());
}
}
}
// achievements
// TODO...
player->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PACIFIED | UNIT_FLAG_IMMUNE_TO_NPC);
player->SetControlled(false, UNIT_STATE_ROOT);
// alert client of pet battle end
if (!m_winningTeam)
// instant battle end
player->GetSession()->SendPetBattleFinished();
else
// delayed battle end and statistics are displayed
player->GetSession()->SendPetBatatleFinalRound(this);
}
if (auto creature = team->GetWildBattlePet())
sBattlePetSpawnMgr->LeftBattle(creature, team == lostTeam);
}
m_phase = PET_BATTLE_PHASE_FINISHED;
}
void PetBattle::HandleRound()
{
TurnInstance = 1;
uint32 OldStates[PET_BATTLE_MAX_TEAMS][BATTLE_PET_MAX_STATES] = { };
// reset state conditions
for (auto &team : Teams)
{
for (auto &battlePet : team->BattlePets)
{
battlePet->States[BATTLE_PET_STATE_CONDITION_WAS_DAMAGED_THIS_ROUND] = 0;
battlePet->States[BATTLE_PET_STATE_CONDITION_DID_DAMAGE_THIS_ROUND] = 0;
}
// store main stat states before they are modified during the round
OldStates[team->GetTeamIndex()][BATTLE_PET_STATE_STAT_SPEED] = team->GetActivePet()->GetSpeed();
OldStates[team->GetTeamIndex()][BATTLE_PET_STATE_STAT_POWER] = team->GetActivePet()->GetPower();
}
uint8 firstTeam = GetFirstAttackingTeam();
// cast abilities that have round start proc type (example: Deflection(490))
Teams[firstTeam]->DoCasts(PET_BATTLE_ABILITY_TURN0_PROC_ON_ROUND_START);
Teams[!firstTeam]->DoCasts(PET_BATTLE_ABILITY_TURN0_PROC_ON_ROUND_START);
// cast non proc abilities
Teams[firstTeam]->DoCasts();
Teams[!firstTeam]->DoCasts();
// -------------------------------------------------------------------------------
PetBattleEffect auraStartEffect(PET_BATTLE_EFFECT_AURA_PROCESSING_BEGIN);
auraStartEffect.TargetActivePet();
// process active battle pet auras
Teams[firstTeam]->ProcessAuras();
Teams[!firstTeam]->ProcessAuras();
PetBattleEffect auraEndEffect(PET_BATTLE_EFFECT_AURA_PROCESSING_END);
auraEndEffect.TargetActivePet();
Effects.push_back(auraStartEffect);
Effects.push_back(auraEndEffect);
// -------------------------------------------------------------------------------
// cast abilities that have round end proc type
Teams[firstTeam]->DoCasts(PET_BATTLE_ABILITY_TURN0_PROC_ON_ROUND_END);
Teams[!firstTeam]->DoCasts(PET_BATTLE_ABILITY_TURN0_PROC_ON_ROUND_END);
// send stat updates if they changed this round
for (auto &team : Teams)
{
auto activePet = team->GetActivePet();
if (OldStates[team->GetTeamIndex()][BATTLE_PET_STATE_STAT_SPEED] != activePet->GetSpeed())
{
// alert client of speed update
PetBattleEffect speedEffect(PET_BATTLE_EFFECT_SET_SPEED);
speedEffect.TargetUpdateStat(activePet->GetGlobalIndex(), activePet->GetSpeed());
Effects.push_back(speedEffect);
}
if (OldStates[team->GetTeamIndex()][BATTLE_PET_STATE_STAT_POWER] != activePet->GetPower())
{
// alert client of power update
PetBattleEffect powerEffect(PET_BATTLE_EFFECT_SET_POWER);
powerEffect.TargetUpdateStat(activePet->GetGlobalIndex(), activePet->GetPower());
Effects.push_back(powerEffect);
}
}
// must be incremented before sending round result
for (auto &team : Teams)
team->ActiveAbility.TurnsPassed++;
// send round result to players
if (m_roundResult == PET_BATTLE_ROUND_RESULT_NONE)
m_roundResult = PET_BATTLE_ROUND_RESULT_NORMAL;
for (auto &team : Teams)
if (auto player = team->GetOwner())
player->GetSession()->SendPetBattleRoundResult(this);
// initialise data for the next round
for (auto &team : Teams)
{
team->RemoveExpiredAuras();
// reduce ability cooldowns
for (auto &battlePet : team->BattlePets)
for (uint8 i = 0; i < BATTLE_PET_MAX_ABILITIES; i++)
if (battlePet->Abilities[i] && battlePet->Abilities[i]->Cooldown)
battlePet->Abilities[i]->Cooldown--;
}
m_round++;
m_roundResult = PET_BATTLE_ROUND_RESULT_NONE;
}
void PetBattle::Update(uint32 diff)
{
if (m_phase != PET_BATTLE_PHASE_IN_PROGRESS)
return;
m_timeSinceLastRound += diff;
// check if all teams are ready to progress round
bool progressRound = true;
for (auto &team : Teams)
{
team->Update();
if (!team->IsReady())
progressRound = false;
}
if (progressRound)
{
// make sure next round timer has elapsed
if (m_timeSinceLastRound >= m_nextRoundTimer)
{
m_timeSinceLastRound = 0;
// execute pending moves before handling the round
for (auto &team : Teams)
{
auto pendingMove = team->GetPendingMove();
switch (pendingMove.MoveType)
{
case PET_BATTLE_MOVE_TYPE_CAST:
{
if (team->CanActivePetCast(pendingMove.AbilityId))
team->ActivePetPrepareCast(pendingMove.AbilityId);
break;
}
case PET_BATTLE_MOVE_TYPE_CATCH:
{
if (team->GetTrapStatus() == PET_BATTLE_TRAP_STATUS_ENABLED)
team->ActivePetPrepareCast(team->GetOwner()->GetBattlePetMgr().GetTrapAbility());
break;
}
case PET_BATTLE_MOVE_TYPE_SWAP_OR_PASS:
{
if (team->CanSwap(pendingMove.battlePet))
SwapActivePet(pendingMove.battlePet);
break;
}
}
}
HandleRound();
// round timer is 1 second for every event (expect aura processing) in the round up to 4 seconds
m_nextRoundTimer = std::min(uint32((Effects.size() - 2) * IN_MILLISECONDS), 4000u);
Effects.clear();
for (auto &team : Teams)
team->IsReady(false);
}
}
}
bool PetBattle::Cast(BattlePet* caster, uint32 abilityId, uint8 turn, int8 procType)
{
// make sure the ability exists
auto abilityEntry = sBattlePetAbilityStore.LookupEntry(abilityId);
if (!abilityEntry)
return false;
// prevent states being updated every tick for multiple turn abilities
if (!turn)
{
// update any states the ability modifies
for (uint32 i = 0; i != sBattlePetAbilityStateStore.GetNumRows(); i++)
{
auto abilityStateEntry = sBattlePetAbilityStateStore.LookupEntry(i);
if (!abilityStateEntry)
continue;
if (abilityStateEntry->AbilityId != abilityId)
continue;
// update battle pet state
UpdatePetState(caster, caster, 0, abilityStateEntry->StateId, caster->States[abilityStateEntry->StateId] + abilityStateEntry->Value);
}
}
// handle ability effects
for (uint32 i = 0; i < sBattlePetAbilityTurnStore.GetNumRows(); i++)
{
auto abilityTurnEntry = sBattlePetAbilityTurnStore.LookupEntry(i);
if (!abilityTurnEntry)
continue;
if (abilityTurnEntry->AbilityId != abilityId)
continue;
// make sure multiple turn ability has done it's full duration
if (abilityTurnEntry->Duration > 1 && abilityTurnEntry->Duration != turn)
continue;
if (abilityTurnEntry->ProcType != procType)
continue;
for (uint32 j = 0; j < sBattlePetAbilityEffectStore.GetNumRows(); j++)
{
auto abilityEffectEntry = sBattlePetAbilityEffectStore.LookupEntry(j);
if (!abilityEffectEntry)
continue;
if (abilityEffectEntry->AbilityTurnId != abilityTurnEntry->Id)
continue;
// initialise ability effect
BattlePetAbilityEffect abilityEffect;
abilityEffect.SetAbilityInfo(abilityId, abilityEffectEntry, abilityEntry->FamilyId);
abilityEffect.SetCaster(caster);
abilityEffect.SetParentBattle(this);
abilityEffect.AddTargets();
abilityEffect.Execute();
}
}
// update ability cooldown
for (uint8 i = 0; i < BATTLE_PET_MAX_ABILITIES; i++)
{
if (caster->Abilities[i] && caster->Abilities[i]->AbilityId == abilityEntry->Id)
{
// make sure ability has a cooldown
if (uint32 cooldown = abilityEntry->Cooldown)
{
caster->Abilities[i]->Cooldown = cooldown;
caster->Abilities[i]->OnCooldown = true;
}
}
}
return true;
}
void PetBattle::SwapActivePet(BattlePet* battlePet)
{
auto team = Teams[battlePet->GetTeamIndex()];
if (!team->IsValidBattlePet(battlePet))
return;
if (!team->CanSwap())
return;
// update team information
team->ResetActiveAbility();
team->SetActivePet(battlePet);
team->SeenAction.insert(battlePet);
// alert client of active pet swap
PetBattleEffect effect(PET_BATTLE_EFFECT_ACTIVE_PET, battlePet->GetGlobalIndex());
effect.TargetActivePet(battlePet->GetGlobalIndex());
Effects.push_back(effect);
}
void PetBattle::UpdatePetState(BattlePet* source, BattlePet* target, uint32 abilityEffect, uint32 state, int32 value, uint16 flags)
{
if (!sBattlePetStateStore.LookupEntry(state))
return;
uint8 modifyType = BattlePetStateModifyType[state];
if (!modifyType)
return;
// make sure value is within allowed bounds
if (modifyType == BATTLE_PET_STATE_MODIFY_TYPE_BOOL)
value = value >= 1 ? 1 : 0;
if (target->States[state] == value)
return;
target->States[state] = value;
// notify client of state change
PetBattleEffect effect(PET_BATTLE_EFFECT_SET_STATE, source->GetGlobalIndex(), flags, abilityEffect, TurnInstance++, 0, 1);
effect.TargetUpdateState(target->GetGlobalIndex(), state, value);
Effects.push_back(effect);
}
void PetBattle::AddAura(BattlePet* source, BattlePet* target, uint32 ability, uint32 abilityEffect, int32 duration, uint16 flags, uint8 maxAllowed)
{
// count current auras for ability
uint32 id = 0;
uint32 auraCount = 0;
for (auto aura : target->Auras)
{
if (aura->GetId() > id)
id = aura->GetId();
if (!aura->HasExpired() && aura->GetAbility() == ability)
auraCount++;
}
id++;
if (!duration && duration != -1)
duration++;
// notify client of aura update
PetBattleEffect effect(PET_BATTLE_EFFECT_AURA_APPLY, source->GetGlobalIndex(), flags, abilityEffect, TurnInstance++, 0, 1);
effect.TargetUpdateAura(target->GetGlobalIndex(), id, ability, duration, 0);
Effects.push_back(effect);
if (flags)
return;
// expire auras above the allowed count
if (maxAllowed && auraCount >= maxAllowed)
{
uint8 removeCount = 1 + auraCount - maxAllowed;
for (auto aura : target->Auras)
{
if (!removeCount)
continue;
if (!aura->HasExpired() && aura->GetAbility() == ability)
{
aura->Expire();
removeCount--;
}
}
}
// create and apply aura
auto aura = new PetBattleAura(this, id, ability, abilityEffect, source, target, duration);
target->Auras.push_back(aura);
aura->OnApply();
}
void PetBattle::Kill(BattlePet* killer, BattlePet* victim, uint32 abilityEffect, uint16 flags)
{
auto victimTeam = Teams[victim->GetTeamIndex()];
if (victimTeam->GetActivePet() == victim)
victimTeam->ResetActiveAbility();
// remove any auras the victim has
for (auto aura : victim->Auras)
aura->Expire();
UpdatePetState(killer, victim, abilityEffect, BATTLE_PET_STATE_IS_DEAD, 1, flags);
m_roundResult = PET_BATTLE_ROUND_RESULT_CATCH_OR_KILL;
}
void PetBattle::Catch(BattlePet* source, BattlePet* target, uint32 abilityEffect)
{
Kill(source, target, abilityEffect, 0);
m_cagedPet = target;
m_roundResult = PET_BATTLE_ROUND_RESULT_CATCH_OR_KILL;
}
typedef std::vector<BattlePet*> ActivePetStore;
uint8 PetBattle::GetFirstAttackingTeam()
{
auto challangerPet = Teams[PET_BATTLE_CHALLANGER_TEAM]->GetActivePet();
auto opponentPet = Teams[PET_BATTLE_OPPONENT_TEAM]->GetActivePet();
// return random team if active pet speed is the same
if (challangerPet->GetSpeed() == opponentPet->GetSpeed())
return urand(PET_BATTLE_CHALLANGER_TEAM, PET_BATTLE_OPPONENT_TEAM);
return (challangerPet->GetSpeed() < opponentPet->GetSpeed());
}
PetBattleTeam* PetBattle::GetTeam(uint64 guid) const
{
for (auto team : Teams)
{
// opponent team in PvE should always be a wild battle pet
if (team->GetTeamIndex() == PET_BATTLE_OPPONENT_TEAM
&& GetType() == PET_BATTLE_TYPE_PVE)
return nullptr;
if (team->GetOwner()->GetGUID() == guid)
return team;
}
return nullptr;
}
// -------------------------------------------------------------------------------
void PetBattleEffect::TargetActivePet(int8 targetPet)
{
PetBattleEffectTarget target;
target.Type = PET_BATTLE_EFFECT_TARGET_ACTIVE_PET;
target.Target = targetPet;
Targets.push_back(target);
}
void PetBattleEffect::TargetUpdateHealth(int8 targetPet, uint32 health)
{
PetBattleEffectTarget target;
target.Type = PET_BATTLE_EFFECT_TARGET_UPDATE_HEALTH;
target.Target = targetPet;
target.Health = health;
Targets.push_back(target);
}
void PetBattleEffect::TargetUpdateState(int8 targetPet, uint32 state, uint32 value)
{
PetBattleEffectTarget target;
target.Type = PET_BATTLE_EFFECT_TARGET_UPDATE_STATE;
target.Target = targetPet;
target.State.StateId = state;
target.State.Value = value;
Targets.push_back(target);
}
void PetBattleEffect::TargetUpdateAura(int8 targetPet, uint32 auraInstance, uint32 ability, int32 duration, uint32 turn)
{
PetBattleEffectTarget target;
target.Type = PET_BATTLE_EFFECT_TARGET_UPDATE_AURA;
target.Target = targetPet;
target.Aura.AuraInstanceId = auraInstance;
target.Aura.AbilityId = ability;
target.Aura.CurrentRound = turn;
target.Aura.RoundsRemaing = duration;
Targets.push_back(target);
}
void PetBattleEffect::TargetUpdateStat(int8 targetPet, uint32 value)
{
PetBattleEffectTarget target;
target.Type = PET_BATTLE_EFFECT_TARGET_UPDATE_STAT;
target.Target = targetPet;
target.StatValue = value;
Targets.push_back(target);
}
// -------------------------------------------------------------------------------
void PetBattleSystem::Update(uint32 diff)
{
m_updatePetBattlesTimer += diff;
m_removePetBattlesTimer += diff;
// remove all pending deletion pet battles
if (m_removePetBattlesTimer >= PET_BATTLE_SYSTEM_REMOVE_BATTLE_TIMER)
{
m_removePetBattlesTimer = 0;
for (auto &petBattleToRemove : m_petBattlesToRemove)
Remove(petBattleToRemove);
m_petBattlesToRemove.clear();
}
// update all pet battles
if (m_updatePetBattlesTimer >= PET_BATTLE_SYSTEM_UPDATE_BATTLE_TIMER)
{
for (auto &petBattleSet : m_petBattles)
{
auto petBattle = petBattleSet.second;
switch (petBattle->GetPhase())
{
// update in progress pet battles
case PET_BATTLE_PHASE_IN_PROGRESS:
petBattle->Update(diff + m_updatePetBattlesTimer);
break;
// mark pet battle for deletion
case PET_BATTLE_PHASE_FINISHED:
m_petBattlesToRemove.insert(petBattle);
break;
}
}
m_updatePetBattlesTimer = 0;
}
}
PetBattle* PetBattleSystem::Create(WorldObject* challenger, WorldObject* opponent, uint8 type)
{
uint32 battleId = m_globalPetBattleId++;
auto petBattle = new PetBattle(battleId, time(nullptr), type);
// challenger will should only be a player
auto challengerTeam = new PetBattleTeam(petBattle, PET_BATTLE_CHALLANGER_TEAM);
challengerTeam->AddPlayer(challenger->ToPlayer());
challengerTeam->ResetActiveAbility();
petBattle->Teams.push_back(challengerTeam);
// opponent can be another player or a wild battle pet
auto opponentTeam = new PetBattleTeam(petBattle, PET_BATTLE_OPPONENT_TEAM);
opponentTeam->ResetActiveAbility();
if (type == PET_BATTLE_TYPE_PVE)
{
opponentTeam->AddWildBattlePet(opponent->ToCreature());
// TODO: nearby wild battle pets should join the pet battle as well
// ...
}
else
opponentTeam->AddPlayer(opponent->ToPlayer());
petBattle->Teams.push_back(opponentTeam);
// add players to system
m_playerPetBattles[challenger->GetGUID()] = battleId;
if (type != PET_BATTLE_TYPE_PVE)
m_playerPetBattles[opponent->GetGUID()] = battleId;
// add pet battle to system
m_petBattles[battleId] = petBattle;
return petBattle;
}
void PetBattleSystem::Remove(PetBattle* petBattle)
{
if (!petBattle)
return;
// remove players from the system
for (auto team : petBattle->Teams)
if (uint64 guid = team->GetOwnerGuid())
m_playerPetBattles.erase(guid);
m_petBattles.erase(petBattle->GetId());
delete petBattle;
}
void PetBattleSystem::ForfietBattle(uint64 guid)
{
// make sure player is currently in a pet battle
auto petBattle = GetPlayerPetBattle(guid);
if (!petBattle)
return;
auto team = petBattle->GetTeam(guid);
ASSERT(team);
ForfietBattle(petBattle, team);
}
void PetBattleSystem::ForfietBattle(PetBattle* petBattle, PetBattleTeam* team)
{
if (!petBattle || !team)
return;
petBattle->FinishBattle(team, true);
}
PetBattle* PetBattleSystem::GetPlayerPetBattle(uint64 guid)
{
// find players pet battle id
auto playerPetBattle = m_playerPetBattles.find(guid);
if (playerPetBattle == m_playerPetBattles.end())
return nullptr;
// find players pet battle instance
auto petBattle = m_petBattles.find(playerPetBattle->second);
if (petBattle == m_petBattles.end())
return nullptr;
return petBattle->second;
}
|
[
"[email protected]"
] | |
a871b15d534a1d334d3fbd8f31e38d17a80ec8a0
|
187e4b1d680a4fde8523d1aa53a3258176133a9c
|
/modules/final_project/src/final_projectWayPoints.cpp
|
9a2b81e4d18c01362b6fb55ef73c3e405a44932e
|
[] |
no_license
|
ohio-university-cs4900-spring-2019-2020/final-project-repository-ctrl-alt-elite
|
ad0c2ccfcc6bb8ba3321d30d03f483e699c63477
|
3b17a40652019291d07eadd20cdbf9a730626515
|
refs/heads/master
| 2022-05-25T04:12:30.506966 | 2020-05-02T02:05:24 | 2020-05-02T02:05:24 | 256,659,299 | 0 | 0 | null | 2020-05-02T02:05:28 | 2020-04-18T03:13:03 |
C++
|
UTF-8
|
C++
| false | false | 590 |
cpp
|
#include "WOWayPointAbstract.h"
#include "final_projectWayPoints.h"
#include "GLViewfinal_project.h"
#include <vector>
#include <iostream>
namespace Aftr
{
WOWP1* WOWP1::New(const WayPointParametersBase& params, float radius )
{
WOWP1* ptr = new WOWP1(params, radius);
ptr->onCreate();
return ptr;
}
WOWP1::WOWP1(const WayPointParametersBase& params, float radius
) : WOWayPointSpherical( params, radius ), IFace( this )
{
}
WOWP1::~WOWP1()
{
}
void WOWP1::onTrigger()
{
std::cout << "WOWP1 waypoint Triggered!" << std::endl << std::endl;
}
} //namespace Aftr
|
[
"[email protected]"
] | |
46e3a3dadad1f8d624a11977efbec3389dba50b8
|
0c0424ab8e03454cea3ca70d7822e90bfde19061
|
/support/cpp/TestShimmer_MultiMote/src/main.cpp
|
4e6488822f76b5b72210927331620fb5f79bc7f1
|
[] |
no_license
|
szte-wsn/szte-wsn
|
cccb1c213d53752b0fe9ba4ae2c4059e98e8368b
|
211a1b553543709f39f443f6060b7df814175236
|
refs/heads/master
| 2016-09-01T23:28:14.396075 | 2013-10-03T13:26:58 | 2013-10-03T13:26:58 | 15,981,075 | 0 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,594 |
cpp
|
/** Copyright (c) 2010, University of Szeged
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* - 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.
* - Neither the name of University of Szeged 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 OWNER 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.
*
* Author: Miklós Maróti
* Author: Péter Ruzicska
*/
#include <QtGui/QApplication>
#include "MainWindow.h"
//#include "window.h"
#include <QDesktopWidget>
#include <QDir>
#include <QDebug>
void initRootDirPath() {
QString path = QDir::currentPath();
int lastSlash = path.lastIndexOf('/');
path.chop(path.size()-lastSlash-1);
extern const QString* rootDirPath; // FIXME Hideous workaround :(
rootDirPath = new QString(path);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
MainWindow w;
w.showMaximized();
initRootDirPath();
//Plot plot;
//plot.show();
/*Window window;
window.resize(window.sizeHint());
int desktopArea = QApplication::desktop()->width() *
QApplication::desktop()->height();
int widgetArea = window.width() * window.height();
if (((float)widgetArea / (float)desktopArea) < 0.75f)
window.show();
else
window.showMaximized();*/
return a.exec();
}
|
[
"[email protected]"
] | |
80c4f554460b59bbb08ff63ea23772835600e49c
|
04b64b6ef60d9f344d54a68a51dda19fc5c5a0e0
|
/cds-0.8.0/cds/gc/tagged/tagged_type.h
|
b4b65204b3f351484ee2b3d005f9778425e91906
|
[] |
no_license
|
rrnewton/temp-data-structure-benchmark
|
93923a6f6927d26b29b18765905a03f7c8e9b79a
|
3fa73e15b08d6d869a6d200dbdabb784cdbb4c75
|
refs/heads/master
| 2020-04-13T05:15:10.869475 | 2012-08-10T21:02:39 | 2012-08-10T21:02:39 | 20,885,751 | 1 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 5,233 |
h
|
/*
This file is a part of libcds - Concurrent Data Structures library
See http://libcds.sourceforge.net/
(C) Copyright Maxim Khiszinsky [khizmax at gmail dot com] 2006-2011
Version 0.8.0
*/
#ifndef __CDS_GC_TAGGED_GC_TAGGED_TYPE_H
#define __CDS_GC_TAGGED_GC_TAGGED_TYPE_H
/*
Editions:
2011.02.19 Maxim.Khiszinsky Moved from cds/gc/tagged/gc.h to separated header
*/
#include <cds/atomic/tagged_ptr.h>
#ifdef CDS_DWORD_CAS_SUPPORTED
namespace cds { namespace gc { namespace tagged {
/// Tag type
typedef uptr_atomic_t ABA_tag ;
/// Tagged data
template <typename T>
struct CDS_TAGGED_ALIGN_ATTRIBUTE tagged_type
{
T volatile m_data ; ///< Data. Condition: sizeof(data) == sizeof(uptr_atomic_t)
ABA_tag volatile m_nTag ; ///< ABA-prevention tag. It might not be decreased during lifetime.
/// Default ctor. Initializes data to \p NULL and the tag to 0.
CDS_CONSTEXPR tagged_type()
: m_data( 0 )
, m_nTag(0)
{
CDS_STATIC_ASSERT( sizeof(T) == sizeof(uptr_atomic_t) ) ;
CDS_STATIC_ASSERT(sizeof(tagged_type<T>) == 2 * sizeof(uptr_atomic_t)) ;
}
/// Constructor
tagged_type(
T data, ///< data
ABA_tag nTag ///< Tag value
)
: m_data( data )
, m_nTag( nTag )
{
CDS_STATIC_ASSERT( sizeof(T) == sizeof(uptr_atomic_t) ) ;
CDS_STATIC_ASSERT(sizeof(tagged_type<T>) == 2 * sizeof(uptr_atomic_t)) ;
}
/// Copy constructor
tagged_type( const tagged_type<T>& v )
: m_data( v.m_data )
, m_nTag( v.m_nTag )
{}
/// Assignment operator.
tagged_type<T>& operator =( const tagged_type<T>& src )
{
CDS_STATIC_ASSERT( sizeof(T) == sizeof(uptr_atomic_t) ) ;
CDS_STATIC_ASSERT(sizeof(tagged_type<T>) == 2 * sizeof(uptr_atomic_t)) ;
m_data = src.m_data ;
m_nTag = src.m_nTag ;
return *this ;
}
/// Get value of tagged_type
T data() { return const_cast<T>( m_data ); } // drop volatile
/// Get value of tagged_type
T data() const { return const_cast<T>( m_data ); } // drop volatile
/// Get reference to tagged_type's value
T& ref() { return const_cast<T&>( m_data ); } // drop volatile
/// Stores \p val into tagged_type and increments its tag
template <typename ORDER>
void set( T val )
{
atomics::store<ORDER>( this, tagged_type(val, m_nTag + 1) ) ;
}
/// Tagged data equality
/**
Tagged value is equal iff its value AND its tag are equal.
*/
friend inline bool operator ==( const tagged_type<T>& r1, const tagged_type<T>& r2 )
{
return r1.m_data == r2.m_data && r1.m_nTag == r2.m_nTag ;
}
//@cond
friend inline bool operator !=( const tagged_type<T>& r1, const tagged_type<T>& r2 )
{
return !( r1 == r2 ) ;
}
//@endcond
} ;
/// CAS specialization for \ref tagged_type<T>
template <typename T>
static inline bool cas_tagged(
tagged_type<T> volatile & dest, ///< Destination. Success CAS increments tag value
const tagged_type<T>& curVal, ///< Current value of \p dest
T dataNew, ///< New value of \p dest
memory_order success_order, ///< memory order constraint for success CAS
memory_order failure_order ///< memory order constraint for failed CAS
)
{
CDS_STATIC_ASSERT( sizeof( tagged_type<T> ) == 2 * sizeof( void * ) ) ;
assert( cds::details::is_aligned<CDS_TAGGED_ALIGNMENT>( &dest ) ) ;
tagged_type<T> newVal( dataNew, curVal.m_nTag + 1 ) ;
return atomics::cas( &dest, curVal, newVal, success_order, failure_order ) ;
}
/// CAS specialization for \ref tagged_type<T>
/**
Template arguments:
\li \p ORDER memory order constraint for success CAS
\li \p T type of value stored in \p dest
*/
template <typename ORDER, typename T>
static inline bool cas_tagged(
tagged_type<T> volatile & dest, ///< Destination. Success CAS increments tag value
const tagged_type<T>& curVal, ///< Current value of \p dest
T dataNew ///< New value of \p dest
)
{
CDS_STATIC_ASSERT( sizeof( tagged_type<T> ) == 2 * sizeof( void * ) ) ;
assert( cds::details::is_aligned<CDS_TAGGED_ALIGNMENT>( &dest ) ) ;
tagged_type<T> newVal( dataNew, curVal.m_nTag + 1 ) ;
return atomics::cas<ORDER>( &dest, curVal, newVal ) ;
}
}}} // namespace cds::gc::tagged
#endif // #ifdef CDS_DWORD_CAS_SUPPORTED
#endif // #ifndef __CDS_GC_TAGGED_GC_TAGGED_TYPE_H
|
[
"fernandes@shadowmaster.(none)"
] |
fernandes@shadowmaster.(none)
|
41a5a2dfcbb3b91851b6eff8f1536ca1b3fe97d9
|
dd99035fc66fb86d0c609582c10d6522a19c2506
|
/main.cpp
|
3b56c13a33a58cea7455ee6f8c1bf342f6fa1050
|
[] |
no_license
|
sunew130/rtmp_test
|
6443e0cf771c49b43a376380d99d9c11b49d1cec
|
d856ffedffc75aeb3a1b9faa23a7372759112514
|
refs/heads/master
| 2021-01-21T15:48:25.162924 | 2017-05-20T01:25:42 | 2017-05-20T01:25:42 | 91,857,965 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 278 |
cpp
|
#include <stdio.h>
#include <QDebug>
#include "RTMPStream.h"
int main(int argc ,char** argv)
{
CRTMPStream crstm;
qDebug()<<"init";
qDebug()<<crstm.Connect("rtmp://localhost/live/test");
crstm.SendH264File("/home/yatai/cuc_ieschool.h264");
crstm.Close();
}
|
[
"[email protected]"
] | |
53af09cad16d88e040c58d106952bc812fd5e38e
|
93e1877ef23c728221afe8ff1f61abe06e25ea3d
|
/overloading/qqqq.cpp
|
5186d66ed2932bd6288be1d3fc2768004292eaf9
|
[] |
no_license
|
shivam-2002/cpp
|
c7c15518b39daa9d3f14c6e0a43083546ff89e57
|
ee9782181eef9b35a7aea677e4357e90c37f2ccc
|
refs/heads/master
| 2020-12-09T15:05:22.562904 | 2020-10-10T08:28:53 | 2020-10-10T08:28:53 | 233,342,712 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 222 |
cpp
|
#include<iostream>
using namespace std;
class A
{
public:
void sum(int x,int y)
{
cout<<x+y<<endl;
}
void sum(double z,double a=8.5)
{
cout<<z+a;
}
}a1;
main()
{
a1.sum(2,3);
a1.sum(3.5);
}
|
[
"[email protected]"
] | |
817eaa8dd2a4ab88fdc8ff116b96c9560a271e76
|
c4ebd248f2fc4a69b609f7df59d274d2519ca340
|
/sopnet/neurons/NeuronExtractor.cpp
|
d1b4123a06a720f589e2065d22e035ee6950afc7
|
[] |
no_license
|
unidesigner/sopnet
|
586ce8950382cfacbadc5c2f36417624134413ae
|
4239561c5c096e8698ea1ced652ebfbd91027256
|
refs/heads/master
| 2021-01-15T21:03:08.967191 | 2013-05-15T14:13:40 | 2013-05-15T14:18:52 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 3,153 |
cpp
|
#include "NeuronExtractor.h"
NeuronExtractor::NeuronExtractor() {
registerInput(_segments, "segments");
registerOutput(_neurons, "neurons");
}
void
NeuronExtractor::updateOutputs() {
_slices.clear();
_neuronIds.clear();
_neurons->clear();
// collect all end slices
foreach (boost::shared_ptr<EndSegment> end, _segments->getEnds())
addSlice(end->getSlice()->getId());
// identify slices belonging to the same neuron
foreach (boost::shared_ptr<ContinuationSegment> continuation, _segments->getContinuations()) {
mergeSlices(
continuation->getSourceSlice()->getId(),
continuation->getTargetSlice()->getId());
}
foreach (boost::shared_ptr<BranchSegment> branch, _segments->getBranches()) {
mergeSlices(
branch->getSourceSlice()->getId(),
branch->getTargetSlice1()->getId());
mergeSlices(
branch->getSourceSlice()->getId(),
branch->getTargetSlice2()->getId());
}
// assign a neuron id to each slice
unsigned int sliceId;
std::set<unsigned int> sameNeuronSlices;
unsigned int neuronId = 0;
foreach (boost::tie(sliceId, sameNeuronSlices), _slices) {
bool alreadyAssigned = false;
foreach (unsigned int id, sameNeuronSlices) {
if (!_neuronIds.count(id)) {
_neuronIds[id] = neuronId;
} else {
alreadyAssigned = true;
break;
}
}
if (!alreadyAssigned)
neuronId++;
}
// sort segments according to the neuron their slices belong to
// prepare neurons
std::vector<boost::shared_ptr<SegmentTree> > neurons(neuronId);
for (unsigned int i = 0; i < neuronId; i++)
neurons[i] = boost::make_shared<SegmentTree>();
// collect all end segments
foreach (boost::shared_ptr<EndSegment> end, _segments->getEnds()) {
unsigned int id = _neuronIds[end->getSlice()->getId()];
neurons[id]->add(end);
}
// collect all continuation segments
foreach (boost::shared_ptr<ContinuationSegment> continuation, _segments->getContinuations()) {
unsigned int id = _neuronIds[continuation->getSourceSlice()->getId()];
neurons[id]->add(continuation);
}
// collect all branch segments
foreach (boost::shared_ptr<BranchSegment> branch, _segments->getBranches()) {
unsigned int id = _neuronIds[branch->getSourceSlice()->getId()];
neurons[id]->add(branch);
}
// finally, put found neurons in output data structure
foreach (boost::shared_ptr<SegmentTree> neuron, neurons)
_neurons->add(neuron);
}
void
NeuronExtractor::addSlice(unsigned int slice) {
_slices[slice].insert(slice);
}
void
NeuronExtractor::mergeSlices(unsigned int slice1, unsigned int slice2) {
// make sure we have partner sets for the given slices
addSlice(slice1);
addSlice(slice2);
// get all partners of slice2 and add them to the partners of slice1
foreach (unsigned int id, _slices[slice2])
_slices[slice1].insert(id);
// slice1 is now the only one who knows all its partners
// the partners of slice1 might not know about slice2 or any of its partners
// for each partner of slice1, add all partners of slice1 to the partner list
foreach (unsigned int id, _slices[slice1]) {
foreach (unsigned int partner, _slices[slice1])
_slices[id].insert(partner);
}
}
|
[
"[email protected]"
] | |
e9551ab5ddc78d8d1d885cbf8026da182c2c4e96
|
44c51d64e4afeede429900f2360a94baae7c7d80
|
/sFuzz/libfuzzer/Mutation.h
|
64d5abea45f09659fbaa9640bb56ec359ee49e1d
|
[] |
no_license
|
Imane219/dustbin
|
a03df34b222ca9e19f7ee768024acb521ba63804
|
fbae0cbd4a2a9de008d1d62d558c1c6e3222b934
|
refs/heads/main
| 2023-03-11T04:01:37.133781 | 2021-03-03T08:24:44 | 2021-03-03T08:24:44 | 333,657,474 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,385 |
h
|
#pragma once
#include <vector>
#include "Common.h"
#include "TargetContainer.h"
#include "Dictionary.h"
#include "FuzzItem.h"
using namespace dev;
using namespace eth;
using namespace std;
namespace fuzzer {
using Dicts = tuple<Dictionary/* code */, Dictionary/* address */>;
class Mutation {
FuzzItem curFuzzItem;
Dicts dicts;
uint64_t effCount = 0;
bytes eff;
void flipbit(int pos);
public:
uint64_t dataSize = 0; //数据长度
uint64_t stageMax = 0;
uint64_t stageCur = 0;
string stageName = "";
static uint64_t stageCycles[32];
Mutation(FuzzItem item, Dicts dicts);
void singleWalkingBit(OnMutateFunc cb);
void twoWalkingBit(OnMutateFunc cb);
void fourWalkingBit(OnMutateFunc cb);
void singleWalkingByte(OnMutateFunc cb);
void twoWalkingByte(OnMutateFunc cb);
void fourWalkingByte(OnMutateFunc cb);
void singleArith(OnMutateFunc cb);
void twoArith(OnMutateFunc cb);
void fourArith(OnMutateFunc cb);
void singleInterest(OnMutateFunc cb);
void twoInterest(OnMutateFunc cb);
void fourInterest(OnMutateFunc cb);
void overwriteWithAddressDictionary(OnMutateFunc cb);
void overwriteWithDictionary(OnMutateFunc cb);
void random(OnMutateFunc cb);
void havoc(OnMutateFunc cb);
bool splice(vector<FuzzItem> items);
};
}
|
[
"[email protected]"
] | |
81bee97a0c35967331e7040c5e8a4ff2cc6758a2
|
6636f1d7b5773cbd22270e6769cf41bff1cd519c
|
/exptree.cpp
|
f2032c9c7f62b7ee38407f10fb78d43f7cbfbdf4
|
[] |
no_license
|
Pranav2907/ADS
|
056b84b0ae42889824953a61d8824c69ee37baf5
|
73dbb5d76fbd939a6a3ca890f2a34d63b2c58cd9
|
refs/heads/master
| 2023-06-23T22:18:12.337189 | 2021-07-24T03:48:55 | 2021-07-24T03:48:55 | 388,991,505 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 5,358 |
cpp
|
#include<iostream>
#define SPACE 10
using namespace std;
struct node{
char data;
node *left, *right;
};
class stack
{
public:
node *st[20];
char st1[20];
char data;
int top,top1;
public:
stack()
{
top=-1;
top1=-1;
}
int isEmpty()
{
if(top==-1)
return 1;
else
return 0;
}
int isEmpty1()
{
if(top1==-1)
return 1;
else
return 0;
}
void push(node *nwnode)
{
top++;
st[top] = nwnode;
}
node *pop()
{
if(isEmpty())
return NULL;
node *nwnode;
nwnode = st[top];
top--;
return(nwnode);
}
void push1(char c)
{
top1++;
st1[top1]=c;
}
char pop1()
{
if(!isEmpty1())
{
char c = st1[top1];
top1--;
return c;
}
}
};
class exptree
{
private:
char post[20];
public:
stack S;
node *root;
exptree()
{
root = NULL;
}
node* newnode(char);
bool isOperator(char);
void convert();
void inorder(node *);
void preorder(node *);
void postorder(node *);
void nr_inorder();
void nr_preorder();
void nr_postorder();
void recursive_traversals();
void non_recursive_traversals();
void print2D(node* r, int space) { // 2.) function
if (r == NULL) // Base case 1
return;
space += SPACE; // Increase distance between levels 2
print2D(r -> right, space); // Process right child first 3
cout << endl;
for (int i = SPACE; i < space; i++) // 5
cout << " "; // 5.1
cout << r -> data << "\n"; // 6
print2D(r -> left, space); // Process left child 7
}
};
node* exptree::newnode(char c)
{
node *tmp = new node;
tmp->data = c;
tmp->left = tmp->right = NULL;
return tmp;
}
bool exptree::isOperator(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='^')
return true;
return false;
}
void exptree::convert()
{
node *t, *t1, *t2;
cout<<"\n Enter Postfix expression:";
cin>>post;
for(int i=0;post[i]!='\0';i++)
{
if(isalpha(post[i]) || isdigit(post[i]))
{
t= newnode(post[i]);
S.push(t);
}
else if(isOperator(post[i]))
{
t = newnode(post[i]);
t2 = S.pop();
t1 = S.pop();
t->left = t1;
t->right = t2;
S.push(t);
}
}
t=S.pop();
root = t;
}
void exptree::inorder(node* temp)
{
if(temp!=NULL)
{
inorder(temp->left);
cout<<temp->data<<" ";
inorder(temp->right);
}
}
void exptree::preorder(node* temp)
{
if(temp!=NULL)
{
cout<<temp->data<<" ";
preorder(temp->left);
preorder(temp->right);
}
}
void exptree::postorder(node* temp)
{
if(temp!=NULL)
{
postorder(temp->left);
postorder(temp->right);
cout<<temp->data<<" ";
}
}
void exptree::nr_inorder()
{
stack S;
node *temp = root;
while(1)
{
while(temp!=NULL)
{
S.push(temp);
temp = temp->left;
}
if(S.isEmpty())
return;
temp = S.pop();
cout<<temp->data<<" ";
temp = temp -> right;
}
}
void exptree::nr_preorder()
{
stack S;
node *temp = root;
while(1)
{
while(temp!=NULL)
{
S.push(temp);
cout<<temp->data<<" ";
temp = temp->left;
}
if(S.isEmpty())
return;
temp = S.pop();
temp = temp->right;
}
}
void exptree::nr_postorder()
{
stack S;
char flag;
node *temp = root;
while(1)
{
while(temp!=NULL)
{
S.push(temp);
S.push1('L');
temp = temp->left;
}
if (S.isEmpty())
return;
else{
temp = S.pop();
flag = S.pop1();
if(flag=='R')
{
cout<<temp->data<<" ";
temp = NULL;
}
else{
S.push(temp);
S.push1('R');
temp = temp->right;
}
}
}
}
void exptree::recursive_traversals()
{
cout<<"\n------------------Recursive Traversals!-------------------------------";
cout<<"\nInorder Traversal : ";
inorder(root);
cout<<"\nPreorder Traversal : ";
preorder(root);
cout<<"\nPostorder Traversal : ";
postorder(root);
}
void exptree::non_recursive_traversals()
{
cout<<"\n------------------Non - Recursive Traversals!-------------------------";
cout<<"\nInorder Traversal : ";
nr_inorder();
cout<<"\nPreorder Traversal : ";
nr_preorder();
cout<<"\nPostorder Traversal : ";
nr_postorder();
}
int main()
{
exptree obj;
int choice,ch;
cout<<"\n1. Create an Expression Tree \n2. Exit"<<endl;
cout<<"\nEnter your choice : ";
cin>>choice;
if(choice==1)
{
obj.convert();
cout<<"\nExpression tree created Sucecssfully!";
while(1)
{
cout<<"\n----------------------------------------------------------------------------------------------";
cout<<"\n1. Create new Tree \n2. Display Recursive Traversals \n3. Display Non Recursive Traversals \n4. Display in 2D \n5. Clear Screen";
cout<<"\nEnter your choice : ";
cin>>ch;
cout<<"\n----------------------------------------------------------------------------------------------";
if(ch==1)
{
obj.convert();
cout<<"\nExpression tree created Successfully!";
}
else if(ch==2)
{
obj.recursive_traversals();
}
else if(ch==3)
{
obj.non_recursive_traversals();
}
else if(ch==4)
{
cout << "PRINT 2D: " << endl;
obj.print2D(obj.root, 2);
}
else if(ch==5)
{
system("cls");
}
else{
cout<<"\nProgram Exited!";
return 0;
}
}
}
else
{
cout<<"\nProgram Exited Successfully!";
}
return 0;
}
|
[
"[email protected]"
] | |
b964cf6e271d4c46e4fe99eac2e4e42ebbb927e2
|
5573ceab5b26e415c18e929718137d0fa0abdf5f
|
/EX06/EX06/Complex.cpp
|
05800288ef48bd0ff3ac374aa5bb94b06b8cda32
|
[] |
no_license
|
HiItsJ/CS172-Online-EX06
|
cd398fa4955e7969e5b071e9c8dbc69bb342a380
|
03ef086fb4939bbe14f1a20b043d1f9fe5ed580d
|
refs/heads/master
| 2021-01-25T01:14:29.012974 | 2017-06-22T05:24:35 | 2017-06-22T05:24:35 | 94,731,484 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,671 |
cpp
|
//
// Complex.cpp
// EX06
//
// Created by Josiah on 6/21/17.
// Copyright © 2017 Josiah. All rights reserved.
//
#include "Complex.hpp"
Complex::Complex(){
a = 0;
b = 0;
}
Complex::Complex(double a){
this->a = a;
b = 0;
}
Complex::Complex(double a, double b){
this->a = a;
this->b = b;
}
double Complex::getRealPart(){
return a;
}
double Complex::getImaginaryPart(){
return b;
}
string Complex::toString(){
return "("+to_string(a)+" + "+to_string(b)+"i)";
}
Complex& Complex::operator+(Complex &c){
a += c.a;
b += c.b;
return *this;
}
Complex& Complex::operator-(Complex &c){
a -= c.a;
b -= c.b;
return *this;
}
Complex& Complex::operator*(Complex &c){
double temp = a*(c.a)-b*(c.b);
b = b*(c.a)+a*(c.b);
a = temp;
return *this;
}
Complex& Complex::operator/(Complex &c){
double temp = (a*(c.a)+b*(c.b))/((c.a)*(c.a)+(c.b)*(c.b));
b = (b*(c.a)-a*(c.b))/((c.a)*(c.a)+(c.b)*(c.b));
a = temp;
return *this;
}
Complex& Complex::operator+=(Complex &c){
this->operator+(c);
return *this;
}
Complex& Complex::operator-=(Complex &c){
this->operator-(c);
return *this;
}
Complex& Complex::operator*=(Complex &c){
this->operator*(c);
return *this;
}
Complex& Complex::operator/=(Complex &c){
this->operator/(c);
return *this;
}
double Complex::operator[](int i){
if (i==0){
return a;
}
if (i==1){
return b;
}
return NULL;
}
ostream& operator<<(ostream& os, Complex& c){
os << c.toString();
return os;
}
/*
istream& operator>>(istream& is, Complex& c){
is >> c.toString();
return is;
}
*/
|
[
"[email protected]"
] | |
ca8700598da15ebf1d110c4fc52a1d4a8e877899
|
e94988ef38684cf4ffcc448dc260c3342ad3e9d0
|
/source/private/ClientWorld.cpp
|
852b4bc69bf765252200090e567a0ab67b56474f
|
[] |
no_license
|
keenaro/Platonica
|
1c73e94d410bed829062f09f48e377227b2bba44
|
9be17e34a66f8abcfa682d67046e3a9c814f862b
|
refs/heads/main
| 2023-04-19T07:38:43.976829 | 2021-05-03T21:35:43 | 2021-05-03T21:35:43 | 312,729,185 | 0 | 2 | null | null | null | null |
UTF-8
|
C++
| false | false | 4,353 |
cpp
|
#include "ClientWorld.h"
#include "RenderObject.h"
#include "UpdateObject.h"
#include <sstream>
#include "Player.h"
#include "GameManager.h"
#include "AsyncChunkManager.h"
ClientWorld::ClientWorld(ClientWorld& connectedWorld) : World(connectedWorld.metaData, connectedWorld.netClient)
{
networkPlayers = connectedWorld.networkPlayers;
}
bool ClientWorld::TryConnect(const char* hostname, int port)
{
InitialiseNetClient();
ENetAddress address;
ENetEvent event;
enet_address_set_host(&address, hostname);
address.port = port;
ENetPeer* netHost = enet_host_connect(netClient, &address, 2, 0);
networkPlayers.push_back(MakeShared<NetworkPlayer>(netHost, 0));
if (netHost == nullptr)
{
DPrint("No available peers for initiating an ENet connection.");
return false;
}
bool connected = false;
while (enet_host_service(netClient, &event, 5000) > 0)
{
if (!connected && event.type == ENET_EVENT_TYPE_CONNECT)
{
DPrintf("Connection to %i:%i succeeded.\n", netHost->address.host, netHost->address.port);
enet_host_flush(netClient);
connected = true;
}
else if(event.type == ENET_EVENT_TYPE_RECEIVE)
{
metaData = *(WorldMetaData*)event.packet->data;
DPrintf("Seed: %i, Region Length: %i\n", metaData.seed, metaData.regionLength);
break;
}
}
if(!connected)
{
enet_peer_reset(netHost);
DPrintf("Connection to %i:%i failed.\n", address.host, address.port);
netHost = nullptr;
}
return netHost;
}
void ClientWorld::InitialiseNetClient()
{
if (enet_initialize() != 0)
{
DPrint("An error occurred while initializing ENet.");
return;
}
netClient = enet_host_create(NULL /* create a client host */,
1 /* only allow 1 outgoing connection */,
2 /* allow up 2 channels to be used, 0 and 1 */,
0 /* assume any amount of incoming bandwidth */,
0 /* assume any amount of outgoing bandwidth */);
if (netClient == nullptr)
{
DPrint("An error occurred while trying to create an ENet client host.");
enet_deinitialize();
return;
}
}
void ClientWorld::Exit()
{
DisconnectFromHost();
chunkManager->Exit();
auto& gameManager = GameManager::Instance();
gameManager.ClearWorld();
gameManager.CreateWorldLoader();
}
void ClientWorld::ExitNetClient()
{
if (netClient)
{
DisconnectFromHost();
}
}
void ClientWorld::DisconnectFromHost()
{
if (auto& hostPlayer = GetHostPlayer())
{
if (ENetPeer* netHost = hostPlayer->GetNetPeer())
{
ENetEvent event;
enet_peer_disconnect(netHost, 0);
while (enet_host_service(netClient, &event, 3000) > 0)
{
switch (event.type)
{
case ENET_EVENT_TYPE_RECEIVE:
enet_packet_destroy(event.packet);
break;
case ENET_EVENT_TYPE_DISCONNECT:
enet_host_flush(netClient);
DPrint("Disconnection succeeded.");
hostPlayer->SetNetPeer(nullptr);
return;
}
}
enet_peer_reset(netHost);
hostPlayer->SetNetPeer(nullptr);
}
}
}
void ClientWorld::Update(float deltaTime)
{
World::Update(deltaTime);
}
void ClientWorld::UpdateGUI()
{
World::UpdateGUI();
}
void ClientWorld::HandlePacket(ENetEvent& event)
{
World::HandlePacket(event);
}
SharedPtr<Chunk> ClientWorld::RequestChunk(const glm::ivec3& chunkPosition)
{
auto chunk = MakeShared<Chunk>(chunkPosition);
ClientRequestChunk(chunkPosition);
return chunk;
}
void ClientWorld::ClientRequestChunk(const glm::ivec3& chunkPosition)
{
std::ostringstream os;
os << "rc " << std::to_string(chunkPosition.x) << " " << std::to_string(chunkPosition.y) << " " << std::to_string(chunkPosition.z);
SendPacket(os.str(), GetHostPlayer()->GetNetPeer(), 1);
}
void ClientWorld::BroadcastPacket(const enet_uint8* data, const int dataSize, const int channel)
{
if (auto& hostPlayer = GetHostPlayer())
{
SendPacket(data, dataSize, hostPlayer->GetNetPeer(), channel);
}
}
void ClientWorld::UpdateNetworkPlayerTransform(const ENetPeer* sender, const uint32_t uniqueId, const Transform<glm::vec3>& transform)
{
if(!uniqueId)
{
GetHostPlayer()->SetTransform(transform);
}
else
{
for (auto& netPlayer : networkPlayers)
{
if (netPlayer->GetUniqueID() == uniqueId)
{
netPlayer->SetTransform(transform);
break;
}
}
}
}
void ClientWorld::OnPlayerDisconnect(const SharedPtr<NetworkPlayer> disconnectee)
{
if(GetHostPlayer() == disconnectee)
{
doExit = true;
}
World::OnPlayerDisconnect(disconnectee);
}
|
[
"[email protected]"
] | |
a0bd48944eab1021726eff2c031fee5ed8d0a9ff
|
a6ea8edbbe881476924e97162e4f6f8e100d4f53
|
/module/include/vsexpress_include/afxribbonedit.h
|
55fbe01c541b0b11fa12f5be92740b340854205f
|
[] |
no_license
|
anonbyte/pvpgn-magic-builder
|
d52e116558dd146f0a75012117f115e40c034e2a
|
127e75647d05931224e55edcfab0cd1d1f067344
|
refs/heads/master
| 2021-01-15T21:07:08.947665 | 2014-05-27T01:52:34 | 2014-05-27T01:52:34 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 4,807 |
h
|
// This MFC Library source code supports the Microsoft Office Fluent User Interface
// (the "Fluent UI") and is provided only as referential material to supplement the
// Microsoft Foundation Classes Reference and related electronic documentation
// included with the MFC C++ library software.
// License terms to copy, use or distribute the Fluent UI are available separately.
// To learn more about our Fluent UI licensing program, please visit
// http://msdn.microsoft.com/officeui.
//
// Copyright (C) Microsoft Corporation
// All rights reserved.
#pragma once
#include "afxribbonbutton.h"
#ifdef _AFX_PACKING
#pragma pack(push, _AFX_PACKING)
#endif
#ifdef _AFX_MINREBUILD
#pragma component(minrebuild, off)
#endif
class CMFCRibbonRichEditCtrl;
class CMFCRibbonSpinButtonCtrl;
class CMFCRibbonEdit : public CMFCRibbonButton
{
friend class CMFCRibbonRichEditCtrl;
DECLARE_DYNCREATE(CMFCRibbonEdit)
// Construction:
public:
CMFCRibbonEdit(UINT nID, int nWidth, LPCTSTR lpszLabel = NULL, int nImage = -1);
virtual ~CMFCRibbonEdit();
protected:
CMFCRibbonEdit();
// Attributes:
public:
CString GetEditText() const { return m_strEdit; };
void SetEditText(CString strText);
void EnableSpinButtons(int nMin, int nMax);
void SetTextAlign(int nAlign); // ES_LEFT, ES_CENTER or ES_RIGHT
int GetTextAlign() const { return m_nAlign; }
int GetWidth(BOOL bInFloatyMode = FALSE) const { return bInFloatyMode ? m_nWidthFloaty : m_nWidth; }
void SetWidth(int nWidth, BOOL bInFloatyMode = FALSE);
// Overrides
public:
virtual BOOL HasLargeMode() const { return FALSE; }
virtual BOOL HasCompactMode() const { return TRUE; }
virtual CSize GetIntermediateSize(CDC* pDC);
virtual CSize GetCompactSize(CDC* pDC);
virtual void Redraw();
virtual void OnHighlight(BOOL bHighlight);
virtual void OnSetFocus(BOOL bSet);
virtual BOOL PreLMouseDown(CPoint point);
virtual BOOL IsHighlighted() const { return m_bIsHighlighted || m_bIsEditFocused; }
virtual BOOL HasFocus() const { return m_bIsEditFocused; }
virtual BOOL HasSpinButtons() const { return m_bHasSpinButtons; }
virtual int GetRangeMin() const { return m_nMin; }
virtual int GetRangeMax() const { return m_nMax; }
virtual void OnDraw(CDC* pDC);
virtual void OnDrawOnList(CDC* pDC, CString strText, int nTextOffset, CRect rect, BOOL bIsSelected, BOOL bHighlighted);
virtual void OnDrawLabelAndImage(CDC* pDC);
virtual void OnLButtonDown(CPoint point);
virtual void OnLButtonUp(CPoint point);
virtual void CopyFrom(const CMFCRibbonBaseElement& src);
virtual BOOL CanBeStretched() { return FALSE; }
virtual void OnAfterChangeRect(CDC* pDC);
virtual void OnShow(BOOL bShow);
virtual CMFCRibbonRichEditCtrl* CreateEdit(CWnd* pWndParent, DWORD dwEditStyle);
virtual void OnEnable(BOOL bEnable);
virtual void DropDownList() {}
virtual BOOL OnKey(BOOL bIsMenuKey);
virtual void OnRTLChanged(BOOL bIsRTL);
virtual void DestroyCtrl();
virtual BOOL SetACCData(CWnd* pParent, CAccessibilityData& data);
// Operations:
protected:
BOOL CreateSpinButton(CMFCRibbonRichEditCtrl* pWndEdit, CWnd* pWndParent);
void CommonInit();
void RepositionRibbonEditCtrl();
// Attributes:
protected:
int m_nWidth;
int m_nWidthFloaty;
int m_nMin;
int m_nMax;
int m_nAlign;
int m_nLabelImageWidth;
BOOL m_bHasDropDownList;
BOOL m_bHasSpinButtons;
BOOL m_bIsEditFocused;
BOOL m_bNotifyCommand;
CString m_strEdit;
CMFCRibbonRichEditCtrl* m_pWndEdit;
CMFCRibbonSpinButtonCtrl* m_pWndSpin;
};
/////////////////////////////////////////////////////////////////////////////
// CMFCRibbonRichEditCtrl
class CMFCRibbonRichEditCtrl : public CRichEditCtrl
{
friend class CMFCRibbonEdit;
DECLARE_DYNAMIC(CMFCRibbonRichEditCtrl)
// Construction
public:
CMFCRibbonRichEditCtrl(CMFCRibbonEdit& edit);
// Attributes
public:
CMFCRibbonEdit& GetOwnerRibbonEdit()
{
return m_edit;
}
protected:
CMFCRibbonEdit& m_edit;
BOOL m_bTracked;
BOOL m_bIsHighlighted;
BOOL m_bIsContextMenu;
CString m_strOldText;
// Overrides
public:
virtual BOOL PreTranslateMessage(MSG* pMsg);
// Implementation
public:
virtual ~CMFCRibbonRichEditCtrl();
protected:
//{{AFX_MSG(CMFCRibbonRichEditCtrl)
afx_msg void OnSetFocus(CWnd* pOldWnd);
afx_msg void OnKillFocus(CWnd* pNewWnd);
afx_msg void OnPaint();
afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
afx_msg LRESULT OnMouseLeave(WPARAM,LPARAM);
afx_msg void OnChange();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
BOOL ProcessClipboardAccelerators(UINT nChar);
};
#ifdef _AFX_MINREBUILD
#pragma component(minrebuild, on)
#endif
#ifdef _AFX_PACKING
#pragma pack(pop)
#endif
|
[
"[email protected]@5d7abbe1-27f8-cb71-bef1-01d8ca34fe51"
] |
[email protected]@5d7abbe1-27f8-cb71-bef1-01d8ca34fe51
|
2d1fe38e221ca44d2a5f2f439d7c4797122f4949
|
1deb3507c241b7e2417ba041c9c71cb5cf7eef06
|
/heroin/d2cdkey.cpp
|
103227f0d59dc46654a738746bc3aa8dfdba8cb3
|
[] |
no_license
|
ChefKeeper/heroinglands
|
2a076db02bc48d578eb1d8d0eb2771079e8a9e9d
|
4585a4adf8c6f3b42e57928fe956cddb5a91ef1a
|
refs/heads/master
| 2016-08-13T02:20:18.085064 | 2009-02-13T20:30:21 | 2009-02-13T20:30:21 | 47,699,838 | 1 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 4,265 |
cpp
|
#include "d2cdkey.hpp"
#include "utility.hpp"
#include "bsha1.hpp"
#include <nil/string.hpp>
#include <iostream>
//code largely copied from JBLS
namespace
{
ulong const alpha_map[] =
{
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x00, 0xFF, 0x01, 0xFF, 0x02, 0x03,
0x04, 0x05, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
0x0C, 0xFF, 0x0D, 0x0E, 0xFF, 0x0F, 0x10, 0xFF,
0x11, 0xFF, 0x12, 0xFF, 0x13, 0xFF, 0x14, 0x15,
0x16, 0xFF, 0x17, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
0x0C, 0xFF, 0x0D, 0x0E, 0xFF, 0x0F, 0x10, 0xFF,
0x11, 0xFF, 0x12, 0xFF, 0x13, 0xFF, 0x14, 0x15,
0x16, 0xFF, 0x17, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
}
char get_hex_digit(ulong byte)
{
byte &= 0xF;
if(byte < 10)
return static_cast<char>(byte + 0x30);
else
return static_cast<char>(byte + 0x37);
}
ulong convert_hex_digit(char input)
{
if(input >= '0' && input <= '9')
return static_cast<ulong>(input - 0x30);
else
return static_cast<ulong>(input - 0x37);
}
std::string read_hex_string_value(std::string const & input)
{
return dword_to_string(nil::string::string_to_number<ulong>(input, std::ios_base::hex));
}
bool hash_d2key(std::string const & cdkey, ulong client_token, ulong server_token, std::string & output, std::string & public_value)
{
ulong checksum = 0;
ulong n, n2, v, v2;
char c1, c2, c;
std::string manipulated_key = cdkey;
for(std::size_t i = 0; i < cdkey.length(); i += 2)
{
c1 = static_cast<char>(alpha_map[cdkey[i]]);
n = c1 * 3;
c2 = static_cast<char>(alpha_map[cdkey[i + 1]]);
n = static_cast<ulong>(c2) + 8 * n;
if (n >= 0x100)
{
n -= 0x100;
checksum |= 1 << (i >> 1);
}
n2 = n;
n2 >>= 4;
manipulated_key[i] = get_hex_digit(n2);
manipulated_key[i + 1] = get_hex_digit(n);
}
v = 3;
for (int i = 0; i < 16; i++)
{
n = convert_hex_digit(manipulated_key[i]);
n2 = v * 2;
n ^= n2;
v += n;
}
v &= 0xFF;
if(v != checksum)
//invalid CD key
return false;
for (int i = 15; i >= 0; i--)
{
c = manipulated_key[i];
if (i > 8)
n = i - 9;
else
n = 0xF - (8 - i);
n &= 0xF;
c2 = manipulated_key[n];
manipulated_key[i] = c2;
manipulated_key[n] = c;
}
v2 = 0x13AC9741;
for(long i = 15; i >= 0; i--)
{
c = nil::string::to_upper(manipulated_key[i]);
manipulated_key[i] = c;
if (c <= '7')
{
v = v2;
c2 = static_cast<char>(v & 0xFF);
c2 &= 7;
c2 ^= c;
v >>= 3;
manipulated_key[i] = c2;
v2 = v;
}
else if (c < 'A')
{
c2 = static_cast<char>(i);
c2 &= 1;
c2 ^= c;
manipulated_key[i] = c2;
}
}
public_value = read_hex_string_value(manipulated_key.substr(2, 6));
std::string hash_data = dword_to_string(client_token);
hash_data += dword_to_string(server_token);
hash_data += read_hex_string_value(manipulated_key.substr(0, 2));
hash_data += public_value;
hash_data += dword_to_string(0);
hash_data += read_hex_string_value(manipulated_key.substr(8, 8));
output = bsha1(hash_data);
return true;
}
|
[
"binrapt@92c0f8f3-e753-0410-a10c-b3df2c4a8671"
] |
binrapt@92c0f8f3-e753-0410-a10c-b3df2c4a8671
|
d70cc9568959ad79683fe6e579a0151c14088d6d
|
aa4c28823c6da36f32ca0e085c279794a9b36cde
|
/ini_parse.cpp
|
6f1c5918efa94f31062513d069260592362fa96e
|
[
"MIT"
] |
permissive
|
Yujiro3/exchanger
|
f4953a393e63d03e2d452ddc01fb129d733b47f4
|
4c923dd6873074193d770c382fc7972eb3e8d65e
|
refs/heads/master
| 2020-04-05T23:26:14.031609 | 2015-11-30T15:10:04 | 2015-11-30T15:10:04 | 14,395,992 | 0 | 0 | null | null | null | null |
SHIFT_JIS
|
C++
| false | false | 2,798 |
cpp
|
/**
* ini_parse.cpp
*
* C++ versions 4.4.5
*
* ini_parse : https://github.com/Yujiro3/iniparser
* Copyright (c) 2011-2013 sheeps.me All Rights Reserved.
*
* @package ini_parse
* @copyright Copyright (c) 2011-2013 sheeps.me
* @author Yujiro Takahashi <[email protected]>
* @filesource
*/
#include <iostream>
#include <fstream>
#include <string>
#include <map>
#include <cstring>
#include <cstdlib>
#include "ini_parse.h"
namespace ini {
/**
* 格納
* @var values_t
*/
static values_t values;
/**
* 置換処理
*
* @access private
* @param string search
* @param string replace
* @param string subject
* @return string
*/
std::string _strReplace(std::string search, std::string replace, std::string subject) {
std::string::size_type pos(subject.find(search));
while (pos != std::string::npos) {
subject.replace(pos, search.length(), replace);
pos = subject.find(search, pos + replace.length());
}
return subject;
}
/**
* キーと値の格納
*
* @access private
* @param string subject
* @return void
*/
void _parse(std::string subject) {
std::string::size_type pos(subject.find("="));
if (pos != std::string::npos) {
ini::values[subject.substr(0, pos)] = subject.substr(pos + 1);
}
}
/**
* iniファイル読み込み
*
* @access public
* @param char* filename
* @return bool
*/
bool load(char* filename) {
std::ifstream ifs(filename);
std::string line;
while (std::getline(ifs, line)) {
if (line[0] == '[' || line[0] == '#' || line[0] == ';' || line.empty()) {
continue;
}
line = _strReplace("\t", "", line);
line = _strReplace(" ", "", line);
_parse(line);
}
return true;
}
/**
* データの取得
*
* @access public
* @param string filename
* @return string
*/
const char* get(std::string key) {
return values[key].c_str();
}
/**
* 数値の取得
*
* @access public
* @param string filename
* @return int
*/
const int value(std::string key) {
return atoi(values[key].c_str());
}
/**
* データのダンプ
*
* @access public
* @param string filename
* @return void
*/
void dump() {
ini::values_t::iterator rows;
for (rows = ini::values.begin(); rows != ini::values.end(); rows++) {
std::cout << (*rows).first << ":" << (*rows).second << std::endl;
}
}
} // namespace ini
|
[
"[email protected]"
] | |
de15f2e17f23ba79ce41bdfdeed808172d1fe45f
|
ae4d9cf742b9f6e5024bcd5bdf4b4473558da9e3
|
/_PSmine/PS모음/codeblock/koistudy/main.cpp
|
4012cdcc8980840f42e3af794dc17aa3fd59419c
|
[] |
no_license
|
son0179/ttt
|
b6d171141e0b7894258cfb367023de62cdc9dd19
|
a5153b0170c0df156c96d9be85b21d73f1f2e21e
|
refs/heads/master
| 2023-02-09T22:01:57.658467 | 2021-01-05T09:14:52 | 2021-01-05T09:14:52 | 200,059,589 | 1 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 754 |
cpp
|
#include<stdio.h>
#include<algorithm>
#include<queue>
using namespace std;
queue <int> q;
int d[1000][1000],dist[1000],n,m;
int main(){
scanf("%d %d",&n,&m);
for(int i=1;i<=n;i++){
dist[i]=2100000000;
}
for(int i=1;i<=m;i++){
int a,b,c;
scanf("%d %d %d",&a,&b,&c);
d[a][b]=c;
d[b][a]=c;
}
q.push(1);
dist[1]=0;
while(!q.empty()){
for(int i=1;i<=n;i++){
if(d[q.front()][i]!=0&&dist[i]>dist[q.front()]+d[q.front()][i]){
dist[i]=dist[q.front()]+d[q.front()][i];
q.push(i);
}
}
q.pop();
}
if(dist[n]==2100000000){
printf("Impossible");
}
else{
printf("%d",dist[n]);
}
}
|
[
"[email protected]"
] | |
a42593cf5a5f1a5c8993a70fd339f83b2385c708
|
dba70d101eb0e52373a825372e4413ed7600d84d
|
/RendererComplement/source/TangentUtil.cpp
|
18616bbb7cc1d248c6201ddf9468a5bb868830b3
|
[] |
no_license
|
nustxujun/simplerenderer
|
2aa269199f3bab5dc56069caa8162258e71f0f96
|
466a43a1e4f6e36e7d03722d0d5355395872ad86
|
refs/heads/master
| 2021-03-12T22:38:06.759909 | 2010-10-02T03:30:26 | 2010-10-02T03:30:26 | 32,198,944 | 0 | 0 | null | null | null | null |
GB18030
|
C++
| false | false | 6,946 |
cpp
|
#include "TangentUtil.h"
#include "RendererHeader.h"
#include "DataCollector.h"
namespace RCP
{
VertexBuffer* TangentUtil::calculateTangentSpace(Renderer* renderer, const VertexBuffer* vb,const IndexBuffer* ib)
{
VertexDeclaration newVD = vb->getVertexDeclaration();
bool hasNormal = newVD.hasElement(VES_NORMAL);
bool hasTangent = newVD.hasElement(VES_TANGENT);
bool hasBinormal = newVD.hasElement(VES_BINORMAL);
if (!hasNormal)
newVD.addElement(VET_FLOAT3,VES_NORMAL);
if (!hasTangent)
newVD.addElement(VET_FLOAT3,VES_TANGENT);
if (!hasBinormal)
newVD.addElement(VET_FLOAT3,VES_BINORMAL);
VertexBuffer* newVB = renderer->createVertexBuffer(vb->getVertexCount(),newVD);
int oldVertexSize = vb->getVertexDeclaration().getSizeInBytes();
int newVertexSize = newVD.getSizeInBytes();
//实际绘制顶点数（要根据三角形来算）
int vertexCount = vb->getVertexCount();
if (ib != NULL)
vertexCount = ( int)ib->getIndexCount();
DataCollector collector;
unsigned int posDataOffset = vb->getVertexDeclaration().getElementOffsetInBytes(VES_POSITION);
unsigned int uvDataOffset = vb->getVertexDeclaration().getElementOffsetInBytes(VES_TEXTURE_COORDINATES);
std::vector<Result> vertexList;
vertexList.resize(vb->getVertexCount());
Vector3 p1,p2,p3;
Vector2 tc1,tc2,tc3;
Result result;
for (int i = 0; i < vertexCount; i+= 3 )
{
unsigned int index[3] = {i,i+1,i+2};
if (ib != NULL)
{
index[0] = (*ib)[index[0]];
index[1] = (*ib)[index[1]];
index[2] = (*ib)[index[2]];
}
const unsigned char* ov1 = vb->getData() + index[0] * oldVertexSize;
const unsigned char* ov2 = vb->getData() + index[1] * oldVertexSize;
const unsigned char* ov3 = vb->getData() + index[2] * oldVertexSize;
collector.getData(p1,ov1 + posDataOffset);
collector.getData(p2,ov2 + posDataOffset);
collector.getData(p3,ov3 + posDataOffset);
if (uvDataOffset != -1)
{
//有uv的情况
collector.getData(tc1,ov1 + uvDataOffset);
collector.getData(tc2,ov2 + uvDataOffset);
collector.getData(tc3,ov3 + uvDataOffset);
result = calculateTangent(p1,p2,p3,tc1,tc2,tc3);
}
else
{
result = calculateTangent(p1,p2,p3);
}
vertexList[index[0]].merge(result);
vertexList[index[1]].merge(result);
vertexList[index[2]].merge(result);
}
unsigned char* vertex = new unsigned char[newVertexSize];
unsigned char* r = new unsigned char[4 * 3 * 3];
unsigned int normDataOffset = newVD.getElementOffsetInBytes(VES_NORMAL);
unsigned int tanDataOffset = newVD.getElementOffsetInBytes(VES_TANGENT);
unsigned int binoDataOffset = newVD.getElementOffsetInBytes(VES_BINORMAL);
for (unsigned int i = 0; i < vb->getVertexCount(); ++i)
{
//copy旧数据
memcpy(vertex,vb->getData() + i * oldVertexSize,oldVertexSize);
vertexList[i].calculate();
((float*)r)[0] = vertexList[i].normal.x;
((float*)r)[1] = vertexList[i].normal.y;
((float*)r)[2] = vertexList[i].normal.z;
((float*)r)[3] = vertexList[i].tangent.x;
((float*)r)[4] = vertexList[i].tangent.y;
((float*)r)[5] = vertexList[i].tangent.z;
((float*)r)[6] = vertexList[i].binormal.x;
((float*)r)[7] = vertexList[i].binormal.y;
((float*)r)[8] = vertexList[i].binormal.z;
if (!hasNormal)
{
memcpy(vertex + normDataOffset + 0 * 4,r + 4 * 0,4);
memcpy(vertex + normDataOffset + 1 * 4,r + 4 * 1,4);
memcpy(vertex + normDataOffset + 2 * 4,r + 4 * 2,4);
}
if (!hasTangent)
{
memcpy(vertex + tanDataOffset + 0 * 4,r + 4 * 3,4);
memcpy(vertex + tanDataOffset + 1 * 4,r + 4 * 4,4);
memcpy(vertex + tanDataOffset + 2 * 4,r + 4 * 5,4);
}
if (!hasBinormal)
{
memcpy(vertex + binoDataOffset + 0 * 4,r + 4 * 6,4);
memcpy(vertex + binoDataOffset + 1 * 4,r + 4 * 7,4);
memcpy(vertex + binoDataOffset + 2 * 4,r + 4 * 8,4);
}
newVB->fill(i,vertex);
}
delete vertex;
delete r;
return newVB;
}
TangentUtil::Result TangentUtil::calculateTangent(const Vector3& p1,const Vector3& p2, const Vector3& p3, const Vector2& tc1, const Vector2& tc2, const Vector2& tc3)
{
Result result;
//side0 is the vector along one side of the triangle of vertices passed in,
//and side1 is the vector along another side. Taking the cross product of these returns the normal.
Vector3 side0 = p1 - p2;
Vector3 side1 = p3 - p1;
//Calculate face normal
Vector3 normal = side1.crossProduct(side0);
normal.normalise();
//Now we use a formula to calculate the tangent.
float deltaV0 = tc1.x - tc2.x;
float deltaV1 = tc3.x - tc1.x;
Vector3 tangent = side0 * deltaV1 - side1 * deltaV0 ;
tangent.normalise();
//Calculate binormal
float deltaU0 = tc1.y - tc2.y;
float deltaU1 = tc3.y - tc1.y;
Vector3 binormal = side0 * deltaU1 - side1 * deltaU0;
binormal.normalise();
//Now, we take the cross product of the tangents to get a vector which
//should point in the same direction as our normal calculated above.
//If it points in the opposite direction (the dot product between the normals is less than zero),
//then we need to reverse the s and t tangents.
//This is because the triangle has been mirrored when going from tangent space to object space.
//reverse tangents if necessary
Vector3 tangentCross = tangent.crossProduct(binormal);
if (tangentCross.dotProduct(normal) < 0.0f)
{
tangent = -tangent;
binormal = -binormal;
}
result.used = 1;
result.normal = normal;
result.tangent = tangent;
result.binormal = binormal;
return result;
}
TangentUtil::Result TangentUtil::calculateTangent(const Vector3& p1,const Vector3& p2, const Vector3& p3)
{
return calculateTangent(p1,p2,p3,generateUV(p1),generateUV(p2),generateUV(p3));
}
Vector2 TangentUtil::generateUV(const Vector3& pos)
{
int face = 0;
float s, t, m;
float x = pos.x;
float y = pos.y;
float z = pos.z;
float ax = abs(x);
float ay = abs(y);
float az = abs(z);
if(ax > ay && ax > az)
{
// x max
m = ax;
if(x > 0){
//+x
s = 0.5f * (z / m + 1.0f);
t = 0.5f * (-y / m + 1.0f);
face = 0;
} else {
//-x
s = 0.5f * (-z / m + 1.0f);
t = 0.5f * (-y / m + 1.0f);
face = 1;
}
} else {
if(ay > ax && ay > az){
m = ay;
if(y > 0){
//+y
s =0.5f * (-x / m + 1.0f);
t = 0.5f * (z / m + 1.0f);
face = 2;
} else {
s = 0.5f * (-x / m + 1.0f);
t = 0.5f * (-z / m + 1.0f);
face = 3;
}
} else {
m = az;
if(z > 0){
//+z
s = 0.5f * (-x / m + 1.0f);
t = 0.5f * (-y / m + 1.0f);
face = 4;
} else {
s = 0.5f * (x / m + 1.0f);
t = 0.5f * (-y / m + 1.0f);
face = 5;
}
}
}
return Vector2(s,t);
}
}
|
[
"[email protected]@c2606ca0-2ebb-fda8-717c-293879e69bc3"
] |
[email protected]@c2606ca0-2ebb-fda8-717c-293879e69bc3
|
b990e19c40ad76bd02c47b47eb67f1e77dc7a52c
|
fdf956416952a4b337ae192d57eda7be1f4c0c33
|
/avl.h
|
2606531d7962d148ad0353fdca55babe9276ff0e
|
[] |
no_license
|
ahmadfaour/HW2_AVL
|
cfc8ebf841db341869dde57b3f4a46e65dfc4fa4
|
88ea7ef0030e7c1a290afef5163abc947e247526
|
refs/heads/master
| 2020-12-30T16:02:01.287663 | 2017-05-17T17:19:45 | 2017-05-17T17:19:45 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 18,706 |
h
|
#ifndef AVLTREE_H_
#define AVLTREE_H_
#include <math.h>
#include <iostream>
#include <string.h>
using namespace std;
template<class T, class Key, class Compare = std::less<Key> >
class AVLNode {
public:
Key key;
T data;
int height;
AVLNode<T, Key, Compare>* left;
AVLNode<T, Key, Compare>* right;
AVLNode<T, Key, Compare>* parent;
/*
* AVLNode- a constructor that creates a new AVLNode receiving its key,data,
* and pointers to its
* son (if there is any) and to the parent (unless this is the root).
* The constructor dinamically allocate memory for the key and data.
*/
AVLNode(const Key& key, const T& data, AVLNode<T, Key, Compare>* left,
AVLNode<T, Key, Compare>* right, AVLNode<T, Key, Compare>* parent) :
key(key), data(data), height(0), left(left), right(right), parent(
parent) {
/*
* AVLNode- an other constructor ,receiving only the height of the Node
* (for building and empty tree).
*/
}
AVLNode(const Key& key, const T& data) :
key((key)), data((data)), height(0), left(NULL), right(NULL), parent(
NULL) {
}
AVLNode(int height) :
key(), data(), height(height), left(NULL), right(NULL), parent(NULL) {
}
AVLNode(int height, AVLNode<T, Key, Compare>* parent) :
key(), data(), height(height), left(NULL), right(NULL), parent(
parent) {
}
AVLNode(const AVLNode<T, Key, Compare>& other) :
key(other.key), data(other.data), height(other.height), left(NULL), right(
NULL), parent(NULL) {
if (other.left != NULL) {
left = new AVLNode<T, Key, Compare>(other.left);
left->parent = this;
}
if (other.right != NULL) {
right = new AVLNode<T, Key, Compare>(other.right);
right->parent = this;
}
}
AVLNode& operator=(const AVLNode<T, Key, Compare>& other) {
if (this != &other) {
AVLNode<T, Key, Compare>* previousLeft = left;
left = new AVLNode(other.left);
if (previousLeft != NULL)
delete previousLeft;
AVLNode<T, Key, Compare>* previousRight = right;
left = new AVLNode(other.right);
if (previousRight != NULL)
delete previousRight;
}
return *this;
}
/*
*AVLNode ~AVLNode-The destructor of a single AVLNode. deletes the memory that was allocated
* in the construction.
* */
/*
*
*
*AVLNode setKey- In case the Node was Empty sets a new key value by
* dynamic allocation.
*/
void setKey(const Key& new_key) {
key = (new_key);
}
/*
*AVLNode setData- In case the Node was Empty sets a new key value by
* dynamic allocation.
* */
void setData(const T& new_data) {
data = (new_data);
}
/*
* AVLNode getKey- returns a pointer to the key by reference.
*/
Key& getKey() {
return key;
}
/*
* AVLNode getData- returns a pointer to the data by reference.
*/
T& getData() {
return data;
}
/*
* AVLNode getHeight- returns the height of the tree
*/
int getHeight() {
return height;
}
/*
* AVLNode updateHeight- updates the height of the tree asuming his sons
* heights are correct.
*/
int updateHeight() {
int leftHeight = (left == NULL ? -1 : left->getHeight());
int rightHeight = (right == NULL ? -1 : right->getHeight());
height = (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
return height;
}
/*
* AVLNode updateAllHeights- updates the height of a single Node and then all
* of its parents untill the root
* the function returns the height of the node received.*/
int updateAllHeights() {
AVLNode<T, Key, Compare>* node = this;
node->updateHeight();
while (node->parent != NULL) {
node = node->parent;
node->updateHeight();
}
return this->height;
}
/*
* AVLNode isLeaf- checks whether
*/
AVLNode<T, Key, Compare>* getLeftSon() {
return left;
}
AVLNode<T, Key, Compare>* getRightSon() {
return right;
}
bool isLeaf() {
if ((getLeftSon() == NULL) && (getRightSon() == NULL))
return true;
return false;
}
bool hasOnlyChild() {
if (((getLeftSon() == NULL || (getRightSon() == NULL)) && !isLeaf())) {
return true;
}
return false;
}
bool hasTwoChilds() {
if (!isLeaf() && !hasOnlyChild())
return true;
return false;
}
bool isLeftSon() {
if (parent == NULL)
return false;
if (parent->left == this) {
return true;
}
return false;
}
bool isRightSon() {
if (parent == NULL)
return false;
if (parent->right == this) {
return true;
}
return false;
}
int getBalance() {
if ((this == NULL) || (height == 0)
|| (this->left == NULL && this->right == NULL))
return 0;
if (this->left == NULL)
return -(this->right->getHeight()) - 1;
if (this->right == NULL)
return (this->left->getHeight()) + 1;
return this->left->getHeight() - this->right->getHeight();
}
bool isBalanced() {
if (this->getBalance() <= 1 && this->getBalance() >= -1)
return true;
return false;
}
void cleanTreeNodes() {
}
/*bool operator< (BinaryNode<T,Key,Compare>* &other) {
Compare compare;
return compare(*this,other);
};*/
};
//=================================================================================================
template<class T, class Key, class Compare = std::less<Key> >
class AVLTree {
public:
Key most_powerful_student;
/*
* AVLTree- The constructor of the tree.
*/
AVLTree() :
most_powerful_student(), root(NULL), size(0) {
}
;
/*
* ~AVLTree- The destructor of the tree. uses an auxilary recursive
* function.
*/
~AVLTree() {
destroyTree(root);
}
/*
* AVLTree getMin- returns the data of the node with the smallest key.
*/
T getMin() const {
if (isEmpty())
return T();
return (min(root)->data);
}
/*
* AVLTree getMax- returns the data of the node with the highest key.
*/
Key getMax() {
if (isEmpty())
return Key();
return (max(root)->key);
}
/*
* AVLTree getSize- returns the number of nodes currently in the tree.
*/
int getSize() const {
return size;
}
/*
* AVLTree insert- insert an element into the tree and make sure it
* keeps the AVL tree rules implemented.
*/
void insert(const Key& key, const T& data) {
if (contains(key))
return;
//*** we compare and ifff se
Compare compare;
if (compare(most_powerful_student, key)) {
most_powerful_student = key;
}
AVLNode<T, Key, Compare>* new_node = rec_insert(key, data, root);
size++;
while (new_node->parent != NULL) {
new_node = new_node->parent;
int prevHeight = new_node->height;
new_node->updateHeight();
if (new_node->height == prevHeight)
break;
if (new_node->isBalanced())
continue;
else {
fixBalance(new_node);
}
}
return;
}
/*
* AVLTree remove- remove an element form the tree and make sure
* the AVL tree rules are implemented.
*/
void remove(const Key& key) {
AVLNode<T, Key, Compare>* to_remove = rec_find(key, root);
if (to_remove == NULL)
return;
//********
// if (getSize() == 1) {
// most_powerful_student = Key();
// } else {
// Compare compare;
// if (!compare(key, most_powerful_student)) {
//
// if (to_remove->left != NULL) {
// most_powerful_student = to_remove->left->key;
// } else {
// most_powerful_student = to_remove->parent->key;
//
// }
//
// }
// }
AVLNode<T, Key, Compare>* new_parent;
/// the function has different cases for wether a node is a leaf/
///has single son/ has two sons.
if (to_remove->left == NULL && to_remove->right == NULL) {
new_parent = removeLeaf(to_remove);
} else {
if (to_remove->left == NULL || to_remove->right == NULL) {
new_parent = removeSingleSon(to_remove);
} else {
new_parent = removeTwoSons(to_remove);
}
}
size--;
if (new_parent == NULL)
return;
///checking al the nodes in the root for the node removes if they
//need a balance.
new_parent->updateAllHeights();
while (new_parent) {
if (!new_parent->isBalanced()) {
fixBalance(new_parent);
}
new_parent = new_parent->parent;
}
if (getSize() == 0) {
most_powerful_student = Key();
}
else{
most_powerful_student=getMax();
}
}
/*
* AVLTree contains -check if the element exist in the tree
*/
bool contains(const Key& key) const {
if (isEmpty())
return false;
AVLNode<T, Key, Compare>* node = rec_find(key, root);
return (node == NULL ? false : true);
}
T* find(const Key& key) const {
AVLNode<T, Key, Compare>* node = rec_find(key, root);
if (node == NULL)
return NULL;
return &(node->data);
}
/*
* AVLTree InOrder- receives a function object, goes through every node
* in the tree by key value and preforms the function on every data in
* the tree.
*/
template<class Function>
void InOrder(Function& f) {
InOrder_rec(f, root);
}
/*
* AVLTree InOrderByKey- receives a function object, goes through every node
* in the tree by key value and preforms the function on every key in
* the tree.
*/
template<class Function>
void InOrderByKey(Function& f) {
InOrder_rec_by_key(f, root);
}
/*
* AVLTree InOrderByNode- receives a function object, goes through every node
* in the tree by key value and preform the function on every node in
* the tree.
*/
template<class Function>
void InOrderByNode(Function& f) {
InOrder_rec_by_node(f, root);
}
/*
* AVLTree clean- removes all the nodes in the tree but not destructing
* the tree itself. needed for creating an empty tree.
*/
void clean() {
destroyTree(root);
root = NULL;
size = 0;
}
void cleanAllButRoot() {
destroyTree(root->left);
destroyTree(root->right);
size = 1;
}
bool isEmpty() const {
if (getSize() == 0)
return true;
return false;
}
void createTreeOfSize(int size) {
int height = log2(size + 1);
createFullTree(height);
int* nodesToRemove = new int(pow(2, (height + 1)) - 1 - size);
removeExtraNodes(nodesToRemove);
delete nodesToRemove;
setSize(size);
}
void DeleteTreeData() {
DeleteTreeData_rec(root);
}
protected:
void setSize(int new_size) {
this->size = new_size;
}
void createFullTree(int height) {
root = new AVLNode<T, Key, Compare>(height);
createFullTreeAux(height - 1, root);
}
void createFullTreeAux(int height, AVLNode<T, Key, Compare>* node) {
if (height < 0)
return;
if (node != root && node->parent->left == node) {
node->left = new AVLNode<T, Key, Compare>(height,
node->parent->left);
node->right = new AVLNode<T, Key, Compare>(height,
node->parent->left);
}
if (node != root && node->parent->right == node) {
node->left = new AVLNode<T, Key, Compare>(height,
node->parent->right);
node->right = new AVLNode<T, Key, Compare>(height,
node->parent->right);
}
if (node == root) {
node->left = new AVLNode<T, Key, Compare>(height, root);
node->right = new AVLNode<T, Key, Compare>(height, root);
}
createFullTreeAux(height - 1, node->left);
createFullTreeAux(height - 1, node->right);
}
void removeExtraNodes(int *nodesToRemove) {
if (nodesToRemove <= 0)
return;
removeExtraNodesAux(nodesToRemove, root);
}
void removeExtraNodesAux(int *nodesToRemove,
AVLNode<T, Key, Compare>* node) {
if (node == NULL)
return;
int oldNodesToRemoveNum = *nodesToRemove;
removeExtraNodesAux(nodesToRemove, node->right);
if (*nodesToRemove > 0) {
removeExtraNodesAux(nodesToRemove, node->right);
}
if (*nodesToRemove > 0) {
removeExtraNodesAux(nodesToRemove, node->left);
}
// incase we havent deletes so far more than 2 nodes.
if (oldNodesToRemoveNum - 2 < *nodesToRemove) {
if (*nodesToRemove > 0 && node->isLeaf()) {
if (node->parent != NULL && node->isLeftSon()) {
node->parent->left = NULL;
}
if (node->parent != NULL && node->isRightSon()) {
node->parent->right = NULL;
}
delete node;
(*nodesToRemove)--;
}
} else {
node->height--;
}
}
AVLNode<T, Key, Compare>* root;
int size;
AVLNode<T, Key, Compare> *min(AVLNode<T, Key, Compare> *node) const {
if (node == NULL)
return NULL;
while (node->left != NULL) {
node = node->left;
}
return node;
}
AVLNode<T, Key, Compare> *max(AVLNode<T, Key, Compare> *node) const {
while (node->right != NULL) {
node = node->right;
}
return node;
}
AVLNode<T, Key, Compare>* rec_insert(const Key& key, const T& data,
AVLNode<T, Key, Compare>* node) {
Compare compare;
if (isEmpty()) {
root = new AVLNode<T, Key, Compare>(key, data, NULL, NULL, NULL);
return root;
}
if (compare(key, node->key)) {
if (node->left == NULL) {
node->left = new AVLNode<T, Key, Compare>(key, data, NULL, NULL,
node);
return node->left;
}
return rec_insert(key, data, node->left);
}
if (compare((node->key), key)) {
if (node->right == NULL) {
node->right = new AVLNode<T, Key, Compare>(key, data, NULL,
NULL, node);
return node->right;
}
return rec_insert(key, data, node->right);
}
return NULL;
}
AVLNode<T, Key, Compare> *removeLeaf(AVLNode<T, Key, Compare> *to_remove) {
if (to_remove == root) {
delete root;
root = NULL;
return NULL;
}
AVLNode<T, Key, Compare>* parent = to_remove->parent;
if (to_remove == parent->left && to_remove != NULL) {
delete (parent->left);
parent->left = NULL;
}
if (to_remove == parent->right && to_remove != NULL) {
delete (parent->right);
parent->right = NULL;
}
return parent;
}
AVLNode<T, Key, Compare> *removeSingleSon(
AVLNode<T, Key, Compare> *to_remove) {
if (root == to_remove && to_remove != NULL) {
if (to_remove->right == NULL) {
root->left->parent = NULL;
this->root = this->root->left;
}
if (to_remove->left == NULL && to_remove != NULL) {
root->right->parent = NULL;
this->root = this->root->right;
}
delete to_remove;
return NULL;
}
AVLNode<T, Key, Compare>* parent = to_remove->parent;
if (to_remove->isLeftSon()) {
if (to_remove->left == NULL) {
parent->left = to_remove->right;
to_remove->right->parent = parent;
} else {
parent->left = to_remove->left;
to_remove->left->parent = parent;
}
}
if (to_remove->isRightSon()) {
if (to_remove->left == NULL) {
parent->right = to_remove->right;
to_remove->right->parent = parent;
} else {
parent->right = to_remove->left;
to_remove->left->parent = parent;
}
}
delete to_remove;
return parent;
}
AVLNode<T, Key, Compare> *removeTwoSons(
AVLNode<T, Key, Compare> *to_remove) {
AVLNode<T, Key, Compare>* nextVal = to_remove->right;
nextVal = min(nextVal);
if (to_remove == root) {
root->data = nextVal->data;
root->key = nextVal->key;
} else {
to_remove->key = nextVal->key;
to_remove->data = nextVal->data;
}
if (nextVal->isLeaf()) {
return removeLeaf(nextVal);
} else
return removeSingleSon(nextVal);
}
AVLNode<T, Key, Compare>* rec_find(const Key& key,
AVLNode<T, Key, Compare>* node) const {
if (node == NULL) {
return NULL;
}
Compare compare;
if (!compare(node->key, key) && !compare(key, node->key)) {
return node;
}
if (compare(key, node->key)) {
return rec_find(key, node->left);
} else
return rec_find(key, node->right);
}
void destroyTree(AVLNode<T, Key, Compare>* node) {
if (node != NULL) {
destroyTree(node->left);
destroyTree(node->right);
delete node;
}
return;
}
void fixBalance(AVLNode<T, Key, Compare>* node) {
int balance = node->getBalance();
if (balance == 2) {
if (node->left->getBalance() >= 0) {
node = rotateLL(node);
}
if (node->left->getBalance() == -1) {
node = rotateLR(node);
}
}
if (balance == -2) {
if (node->right->getBalance() <= 0) {
node = rotateRR(node);
}
if (node->right->getBalance() == 1) {
node = rotateRL(node);
}
}
}
AVLNode<T, Key, Compare> *rotateLL(AVLNode<T, Key, Compare> *b) {
bool isLeftSon = b->isLeftSon();
AVLNode<T, Key, Compare>* a = b->left;
b->left = a->right;
a->parent = b->parent;
if (b->left != NULL) {
b->left->parent = b;
}
a->right = b;
b->parent = a;
if (a->parent != NULL) {
if (isLeftSon) {
a->parent->left = a;
} else
a->parent->right = a;
} else {
root = a;
}
b->updateHeight();
a->updateHeight();
return a;
}
AVLNode<T, Key, Compare> *rotateLR(AVLNode<T, Key, Compare> *b) {
b->left = rotateRR(b->left);
return rotateLL(b);
}
AVLNode<T, Key, Compare> *rotateRR(AVLNode<T, Key, Compare> *b) {
bool isLeftSon = b->isLeftSon();
AVLNode<T, Key, Compare>* a = b->right;
b->right = a->left;
a->parent = b->parent;
if (b->right != NULL) {
b->right->parent = b;
}
a->left = b;
b->parent = a;
if (a->parent != NULL) {
if (isLeftSon) {
a->parent->left = a;
} else
a->parent->right = a;
} else {
root = a;
}
a->updateHeight();
b->updateHeight();
return a;
}
AVLNode<T, Key, Compare> *rotateRL(AVLNode<T, Key, Compare> *b) {
b->right = rotateLL(b->right);
return rotateRR(b);
}
template<class Function>
void InOrder_rec(Function& f, AVLNode<T, Key, Compare>* node) {
if (node != NULL) {
InOrder_rec(f, node->left);
f(node->data);
InOrder_rec(f, node->right);
}
}
template<class Function>
void InOrder_rec_by_key(Function& f, AVLNode<T, Key, Compare>* node) {
if (node != NULL) {
InOrder_rec_by_key(f, node->left);
f(node->key);
InOrder_rec_by_key(f, node->right);
}
}
template<class Function>
void InOrder_rec_by_node(Function& f, AVLNode<T, Key, Compare>* node) {
if (node != NULL) {
InOrder_rec_by_node(f, node->left);
f(node);
InOrder_rec_by_node(f, node->right);
}
}
template<class Function>
void InOrder_removalrec(Function& f, AVLNode<T, Key, Compare>* node) {
if (node != NULL) {
InOrder_removalrec(f, node->left);
InOrder_removalrec(f, node->right);
f(node->data);
}
}
void DeleteTreeData_rec(AVLNode<T, Key, Compare>* node) {
if (node != NULL) {
DeleteTreeData_rec(node->left);
DeleteTreeData_rec(node->right);
delete node->data;
}
}
}
;
#endif /* AVLTREE2_H_ */
|
[
"[email protected]"
] | |
ce0595a7eb24808185e1975fc0816ee2dfb2b4b5
|
fcc36a3043cdacb02f2e85f1361f765de1e6743f
|
/class_7.cpp
|
612c8b08409286a3163e1f709f061b942c10a437
|
[] |
no_license
|
muskanmahajan37/C-_tutorials
|
f00ae5a04b9325c8d40bcbd04a0460aa6f7973d6
|
6e4bcfb7d3ed9fce87a5c720c156cda9a238d922
|
refs/heads/master
| 2022-03-30T03:04:38.465048 | 2020-01-13T17:38:02 | 2020-01-13T17:38:02 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 131 |
cpp
|
// function
#include<iostream>
using namespace std;
void add()
{
cout<<"hello pardeep";
}
int main()
{
add();
}
|
[
"[email protected]"
] | |
6b8f7d15a8f7d80337d3a68fa9df2180d2cd5775
|
fee9f04728f279a217e3add39d1fba915b6debf4
|
/RosOn5.cydsn/ros_lib/std_msgs/Char.h
|
c26fb0b306522321bb88a18e43ae1cdd86c9ebdb
|
[] |
no_license
|
chuck-h/RosOn5
|
f09a95054d0282324f00bd715b035335b63553e3
|
3ce89eb7ae23f7a395f5860f959aac7877b4f507
|
refs/heads/master
| 2021-01-02T22:18:41.868126 | 2016-01-18T20:09:38 | 2016-01-18T20:09:38 | 35,055,718 | 1 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 907 |
h
|
#ifndef _ROS_std_msgs_Char_h
#define _ROS_std_msgs_Char_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
namespace std_msgs
{
class Char : public ros::Msg
{
public:
uint8_t data;
Char():
data(0)
{
}
virtual int serialize(unsigned char *outbuffer) const
{
int offset = 0;
#ifndef ROS_MSG_DONT_SERIALIZE
*(outbuffer + offset + 0) = (this->data >> (8 * 0)) & 0xFF;
offset += sizeof(this->data);
#endif
return offset;
}
virtual int deserialize(unsigned char *inbuffer)
{
int offset = 0;
#ifndef ROS_MSG_DONT_DESERIALIZE
this->data = ((uint8_t) (*(inbuffer + offset)));
offset += sizeof(this->data);
#endif
return offset;
}
const char * getType(){ return "std_msgs/Char"; };
const char * getMD5(){ return "1bf77f25acecdedba0e224b162199717"; };
};
}
#endif
|
[
"[email protected]"
] | |
23f20b14620b86589863ca9f197be25209eb6dcb
|
83e8686c0e7013e2e3db2bb78b5c52761b70b2ed
|
/effecteditor.h
|
33780c14e1aae46caefc6e8a22f2564cabac8afd
|
[
"MIT"
] |
permissive
|
yvt/terravox
|
8108425f44d829551c15e38bc8c58d5832e03ea2
|
25412f892f295d2c259d9c5df3387d635616d555
|
refs/heads/master
| 2021-06-09T22:21:00.248208 | 2017-09-22T11:50:29 | 2017-09-22T11:50:29 | 30,805,510 | 31 | 7 | null | 2015-02-26T15:49:28 | 2015-02-14T18:58:19 |
C++
|
UTF-8
|
C++
| false | false | 375 |
h
|
#ifndef EFFECTEDITOR_H
#define EFFECTEDITOR_H
#include <QWidget>
namespace Ui {
class EffectEditor;
}
class EffectEditor : public QWidget
{
Q_OBJECT
public:
explicit EffectEditor(QWidget *editor, QWidget *parent = 0);
~EffectEditor();
signals:
void applyEffect();
void revertEffect();
private:
Ui::EffectEditor *ui;
};
#endif // EFFECTEDITOR_H
|
[
"[email protected]"
] | |
8a2ce9d88e64b71c6885e3d2b6d4114be774891f
|
55e0710904a0997f663f9d5152547a71ea09ae83
|
/Apriori/HashTree.h
|
b1569beaeaf29eab9a92b439a0232d193e52560a
|
[
"MIT"
] |
permissive
|
juanjuanShu/codes
|
12cea1d0fe0b16d9fbaee3853aeb3712e7ef2b7a
|
905e70e79a21832ed751598d15ed71c420a310ce
|
refs/heads/main
| 2023-03-24T01:28:43.176486 | 2021-03-17T09:06:47 | 2021-03-17T09:06:47 | 310,597,736 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 1,749 |
h
|
#ifndef HASHNODE_H_INCLUDED
#define HASHNODE_H_INCLUDED
#include <unordered_map>
#include <memory>
#include <vector>
template<typename T>
class HashNode;
template<typename T>
using HashTree = HashNode<T>;
// T is key's type.
template <typename T>
class HashNode
{
public:
HashNode() = default;
HashNode(const HashNode<T> &) = delete;
void insert(const T &);
void insert(const std::vector<T>&);
std::shared_ptr<HashNode<T>> next(const T &);
bool search(const T &);
bool search(const std::vector<T> &);
private:
std::unordered_map<T, std::shared_ptr<HashNode<T>>> _hashTable;
};
template <typename T>
void HashNode<T>::insert(const T &key)
{
// The key has inserted into the hash tree, just return.
if (_hashTable.count(key))
return;
_hashTable[key] = std::make_shared<HashNode<T>>();
}
template <typename T>
void HashNode<T>::insert(const std::vector<T> &keys)
{
insert(keys[0]);
std::shared_ptr<HashNode<T>> p = _hashTable[keys[0]];
for(unsigned int i = 1; i < keys.size(); ++i)
{
p->insert(keys[i]);
p = p->next(keys[i]);
}
}
template <typename T>
std::shared_ptr<HashNode<T>> HashNode<T>::next(const T &key)
{
if (!_hashTable.count(key))
return nullptr;
return _hashTable[key];
}
template <typename T>
bool HashNode<T>::search(const T &key)
{
return _hashTable.count(key);
}
template <typename T>
bool HashNode<T>::search(const std::vector<T> &keys)
{
if(!search(keys[0])) return false;
std::shared_ptr<HashNode<T>> p = _hashTable[keys[0]];
for(unsigned int i = 1; i < keys.size(); ++i)
{
if (!p->search(keys[i]))
return false;
p = p->next(keys[i]);
}
return true;
}
#endif
|
[
"[email protected]"
] | |
9184e24962711cb5e55ab546edb42345fc5a2b4a
|
f0bc7b1514d759d53dd66201ed96443cb4d3cfbb
|
/Competitive coding/Hacker blocks/614_A.cpp
|
1dfb3799913ba520e09efea0a5b33e425cae04fd
|
[] |
no_license
|
Prajjwalkr1999/Codes
|
39074a3c4acb873c245217f57af1d81a9b2ea3c2
|
e60287cbbec0f47d635f6a1b139f184d7f66c740
|
refs/heads/master
| 2023-01-01T22:24:54.947736 | 2020-10-22T09:24:41 | 2020-10-22T09:24:41 | 306,282,105 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 638 |
cpp
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define ld long double
#define F first
#define S second
#define P pair<int,int>
#define pb push_back
const int N = 100005;
int main()
{
ios_base:: sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ll t;cin>>t;while(t--)
{
ll i, j, k, n, m, ans = 0, cnt = 0, sum = 0;
cin >> n;
ll a[n];
map<ll,ll> block;
for ( i = 0; i < n; i++) {
cin >> m;
}
}
}
|
[
"[email protected]"
] | |
6bba746f141be940590274f898eaad00691ca84e
|
07c6a81e5234f8b5976b909daa09b916b0a5cb9c
|
/src/globalstrikeclient.h
|
3c4ea5053a8a671a48facfeebd213324130e6c9c
|
[
"MIT"
] |
permissive
|
dthornton22/GlobalStrike
|
47e64be82e996bc31be878ca188ec697ecd82e51
|
eee7e1b9c14eea813b046c6e32fcbbe0e5445ca4
|
refs/heads/main
| 2023-02-02T08:45:31.147107 | 2020-12-17T00:08:29 | 2020-12-17T00:08:29 | 322,130,148 | 1 | 1 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,091 |
h
|
#ifndef GLOBALSTRIKECLIENT_H
#define GLOBALSTRIKECLIENT_H
#include <QObject>
#include <QTcpSocket>
#include <QNetworkProxy>
#include <QFile>
#include <QTextStream>
#include <QByteArray>
#include <QDateTime>
#include <QQueue>
#include "sqldatabase.h"
#include "player.h"
class GlobalStrikeClient : public QObject
{
Q_OBJECT
public:
GlobalStrikeClient();
~GlobalStrikeClient();
signals:
void deny();
void lobbyIPUpdate(QString, quint16);
void newClientDB(QString);
void readyDBToggle(QString);
void scoreUpdate(QString);
void lobbyChanged();
void gameIsStarting();
void animateWhite();
void animateOrange();
void animateGreen();
void animateYellow();
void animateBlack();
void animateLaunchWhite(int, int);
void animateLaunchOrange(int, int);
void animateLaunchGreen(int, int);
void animateLaunchYellow(int, int);
void animateLaunchBlack(int, int);
void explodeMissile(QString);
void connectionLost();
public slots:
bool connectToServer(QString ipAddress, quint16 portNum);
void launchCommand(QString);
void interceptCommand(QString);
void yieldKillPoint(QString);
void readyToggle();
void handshake();
void disconnectRequest();
void processPendingMessages();
void Dequeue();
private:
void writeMessage(QByteArray message);
void processLaunch(QTextStream&);
void processIntercept(QTextStream&);
void processScoreUpdates(QTextStream&);
void processReadyToggleData(QTextStream&);
void processGreeting(QTextStream&);
void processDeny(QTextStream&);
void processNewClient(QTextStream&);
void processDisconnectRequest(QTextStream&);
void LogEvent(QByteArray);
void LogEvent(QString);
void whichCountry(QString, bool, QString);
public:
int playerID;
QString playerName;
QString password;
QTcpSocket* client;
QFile file;
quint16 lineNum = 1;
QDateTime now;
quint16 portNum;
QString ipAddress;
QList<QString> takenCountryNames;
QList<QString> playerNames;
bool targetedBy[5];
bool ingame;
struct pendingMissile
{
QString originCountry;
QTimer* shotTimer;
};
QQueue<pendingMissile> missileQueue;
};
#endif // GLOBALSTRIKECLIENT_H
|
[
"[email protected]"
] | |
dcf86357dfc17e50fbe2b1f35514253d53264605
|
f6439b5ed1614fd8db05fa963b47765eae225eb5
|
/ui/views/window/non_client_view.h
|
721097c6ce1124eb20eea23ac18af99d1fb944a3
|
[
"BSD-3-Clause"
] |
permissive
|
aranajhonny/chromium
|
b8a3c975211e1ea2f15b83647b4d8eb45252f1be
|
caf5bcb822f79b8997720e589334266551a50a13
|
refs/heads/master
| 2021-05-11T00:20:34.020261 | 2018-01-21T03:31:45 | 2018-01-21T03:31:45 | 118,301,142 | 2 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 10,122 |
h
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef UI_VIEWS_WINDOW_NON_CLIENT_VIEW_H_
#define UI_VIEWS_WINDOW_NON_CLIENT_VIEW_H_
#include "ui/views/view.h"
#include "ui/views/view_targeter_delegate.h"
namespace gfx {
class Path;
}
namespace views {
class ClientView;
////////////////////////////////////////////////////////////////////////////////
// NonClientFrameView
//
// An object that subclasses NonClientFrameView is a View that renders and
// responds to events within the frame portions of the non-client area of a
// window. This view does _not_ contain the ClientView, but rather is a sibling
// of it.
class VIEWS_EXPORT NonClientFrameView : public View,
public ViewTargeterDelegate {
public:
// Internal class name.
static const char kViewClassName[];
enum {
// Various edges of the frame border have a 1 px shadow along their edges;
// in a few cases we shift elements based on this amount for visual appeal.
kFrameShadowThickness = 1,
// In restored mode, we draw a 1 px edge around the content area inside the
// frame border.
kClientEdgeThickness = 1,
};
virtual ~NonClientFrameView();
// Sets whether the window should be rendered as active regardless of the
// actual active state. Used when bubbles become active to make their parent
// appear active. A value of true makes the window render as active always,
// false gives normal behavior.
void SetInactiveRenderingDisabled(bool disable);
// Used to determine if the frame should be painted as active. Keyed off the
// window's actual active state and |inactive_rendering_disabled_|.
bool ShouldPaintAsActive() const;
// Helper for non-client view implementations to determine which area of the
// window border the specified |point| falls within. The other parameters are
// the size of the sizing edges, and whether or not the window can be
// resized.
int GetHTComponentForFrame(const gfx::Point& point,
int top_resize_border_height,
int resize_border_thickness,
int top_resize_corner_height,
int resize_corner_width,
bool can_resize);
// Returns the bounds (in this View's parent's coordinates) that the client
// view should be laid out within.
virtual gfx::Rect GetBoundsForClientView() const = 0;
virtual gfx::Rect GetWindowBoundsForClientBounds(
const gfx::Rect& client_bounds) const = 0;
// This function must ask the ClientView to do a hittest. We don't do this in
// the parent NonClientView because that makes it more difficult to calculate
// hittests for regions that are partially obscured by the ClientView, e.g.
// HTSYSMENU.
virtual int NonClientHitTest(const gfx::Point& point) = 0;
virtual void GetWindowMask(const gfx::Size& size,
gfx::Path* window_mask) = 0;
virtual void ResetWindowControls() = 0;
virtual void UpdateWindowIcon() = 0;
virtual void UpdateWindowTitle() = 0;
// View:
virtual void GetAccessibleState(ui::AXViewState* state) OVERRIDE;
virtual const char* GetClassName() const OVERRIDE;
protected:
virtual void OnBoundsChanged(const gfx::Rect& previous_bounds) OVERRIDE;
NonClientFrameView();
private:
// ViewTargeterDelegate:
virtual bool DoesIntersectRect(const View* target,
const gfx::Rect& rect) const OVERRIDE;
// Prevents the non-client frame view from being rendered as inactive when
// true.
bool inactive_rendering_disabled_;
};
////////////////////////////////////////////////////////////////////////////////
// NonClientView
//
// The NonClientView is the logical root of all Views contained within a
// Window, except for the RootView which is its parent and of which it is the
// sole child. The NonClientView has two children, the NonClientFrameView which
// is responsible for painting and responding to events from the non-client
// portions of the window, and the ClientView, which is responsible for the
// same for the client area of the window:
//
// +- views::Widget ------------------------------------+
// | +- views::RootView ------------------------------+ |
// | | +- views::NonClientView ---------------------+ | |
// | | | +- views::NonClientFrameView subclass ---+ | | |
// | | | | | | | |
// | | | | << all painting and event receiving >> | | | |
// | | | | << of the non-client areas of a >> | | | |
// | | | | << views::Widget. >> | | | |
// | | | | | | | |
// | | | +----------------------------------------+ | | |
// | | | +- views::ClientView or subclass --------+ | | |
// | | | | | | | |
// | | | | << all painting and event receiving >> | | | |
// | | | | << of the client areas of a >> | | | |
// | | | | << views::Widget. >> | | | |
// | | | | | | | |
// | | | +----------------------------------------+ | | |
// | | +--------------------------------------------+ | |
// | +------------------------------------------------+ |
// +----------------------------------------------------+
//
// The NonClientFrameView and ClientView are siblings because due to theme
// changes the NonClientFrameView may be replaced with different
// implementations (e.g. during the switch from DWM/Aero-Glass to Vista Basic/
// Classic rendering).
//
class VIEWS_EXPORT NonClientView : public View, public ViewTargeterDelegate {
public:
// Internal class name.
static const char kViewClassName[];
NonClientView();
virtual ~NonClientView();
// Returns the current NonClientFrameView instance, or NULL if
// it does not exist.
NonClientFrameView* frame_view() const { return frame_view_.get(); }
// Replaces the current NonClientFrameView (if any) with the specified one.
void SetFrameView(NonClientFrameView* frame_view);
// Replaces the current |overlay_view_| (if any) with the specified one.
void SetOverlayView(View* view);
// Returns true if the ClientView determines that the containing window can be
// closed, false otherwise.
bool CanClose();
// Called by the containing Window when it is closed.
void WindowClosing();
// Replaces the frame view with a new one. Used when switching window theme
// or frame style.
void UpdateFrame();
// Prevents the window from being rendered as deactivated when |disable| is
// true, until called with |disable| false. Used when a sub-window is to be
// shown that shouldn't visually de-activate the window.
void SetInactiveRenderingDisabled(bool disable);
// Returns the bounds of the window required to display the content area at
// the specified bounds.
gfx::Rect GetWindowBoundsForClientBounds(const gfx::Rect client_bounds) const;
// Determines the windows HT* code when the mouse cursor is at the
// specified point, in window coordinates.
int NonClientHitTest(const gfx::Point& point);
// Returns a mask to be used to clip the top level window for the given
// size. This is used to create the non-rectangular window shape.
void GetWindowMask(const gfx::Size& size, gfx::Path* window_mask);
// Tells the window controls as rendered by the NonClientView to reset
// themselves to a normal state. This happens in situations where the
// containing window does not receive a normal sequences of messages that
// would lead to the controls returning to this normal state naturally, e.g.
// when the window is maximized, minimized or restored.
void ResetWindowControls();
// Tells the NonClientView to invalidate the NonClientFrameView's window icon.
void UpdateWindowIcon();
// Tells the NonClientView to invalidate the NonClientFrameView's window
// title.
void UpdateWindowTitle();
// Get/Set client_view property.
ClientView* client_view() const { return client_view_; }
void set_client_view(ClientView* client_view) {
client_view_ = client_view;
}
// Layout just the frame view. This is necessary on Windows when non-client
// metrics such as the position of the window controls changes independently
// of a window resize message.
void LayoutFrameView();
// Set the accessible name of this view.
void SetAccessibleName(const base::string16& name);
// NonClientView, View overrides:
virtual gfx::Size GetPreferredSize() const OVERRIDE;
virtual gfx::Size GetMinimumSize() const OVERRIDE;
virtual gfx::Size GetMaximumSize() const OVERRIDE;
virtual void Layout() OVERRIDE;
virtual void GetAccessibleState(ui::AXViewState* state) OVERRIDE;
virtual const char* GetClassName() const OVERRIDE;
virtual views::View* GetTooltipHandlerForPoint(
const gfx::Point& point) OVERRIDE;
protected:
// NonClientView, View overrides:
virtual void ViewHierarchyChanged(
const ViewHierarchyChangedDetails& details) OVERRIDE;
private:
// ViewTargeterDelegate:
virtual View* TargetForRect(View* root, const gfx::Rect& rect) OVERRIDE;
// A ClientView object or subclass, responsible for sizing the contents view
// of the window, hit testing and perhaps other tasks depending on the
// implementation.
ClientView* client_view_;
// The NonClientFrameView that renders the non-client portions of the window.
// This object is not owned by the view hierarchy because it can be replaced
// dynamically as the system settings change.
scoped_ptr<NonClientFrameView> frame_view_;
// The overlay view, when non-NULL and visible, takes up the entire widget and
// is placed on top of the ClientView and NonClientFrameView.
View* overlay_view_;
// The accessible name of this view.
base::string16 accessible_name_;
DISALLOW_COPY_AND_ASSIGN(NonClientView);
};
} // namespace views
#endif // UI_VIEWS_WINDOW_NON_CLIENT_VIEW_H_
|
[
"[email protected]"
] | |
dc0fa053053e851c73b3d1e4e08f955981f3586b
|
5470644b5f0834b9646649da365c96101a2f9b2a
|
/Sources/Elastos/LibCore/src/elastos/utility/concurrent/CLinkedBlockingQueue.cpp
|
616bab4064e0aa11b2529d8f5f7e3489dcea08cf
|
[] |
no_license
|
dothithuy/ElastosRDK5_0
|
42372da3c749170581b5ee9b3884f4a27ae81608
|
2cf231e9f09f8b3b8bcacb11080b4a87d047833f
|
refs/heads/master
| 2021-05-13T15:02:22.363934 | 2015-05-25T01:54:38 | 2015-05-25T01:54:38 | 116,755,452 | 1 | 0 | null | 2018-01-09T02:33:06 | 2018-01-09T02:33:06 | null |
UTF-8
|
C++
| false | false | 17,492 |
cpp
|
#include "CLinkedBlockingQueue.h"
#include "CAtomicInteger32.h"
#include <elastos/Math.h>
using Elastos::Utility::Concurrent::Atomic::CAtomicInteger32;
namespace Elastos {
namespace Utility {
namespace Concurrent {
CLinkedBlockingQueue::Itr::Itr(
/* [in] */ CLinkedBlockingQueue* owner)
: mOwner(owner)
{
mOwner->FullyLock();
mCurrent = mOwner->mHead->mNext;
if (mCurrent != NULL) {
mCurrentElement = mCurrent->mItem;
}
mOwner->FullyUnlock();
}
CAR_INTERFACE_IMPL_LIGHT(CLinkedBlockingQueue::Itr, IIterator);
ECode CLinkedBlockingQueue::Itr::HasNext(
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
*result = mCurrent != NULL;
return NOERROR;
}
AutoPtr<CLinkedBlockingQueue::Node> CLinkedBlockingQueue::Itr::NextNode(
/* [in] */ CLinkedBlockingQueue::Node* p)
{
for (;;) {
AutoPtr<Node> s = p->mNext;
if (s.Get() == p) {
return mOwner->mHead->mNext;
}
if (s == NULL || s->mItem != NULL) {
return s;
}
p = s;
}
}
ECode CLinkedBlockingQueue::Itr::Next(
/* [out] */ IInterface** object)
{
VALIDATE_NOT_NULL(object);
mOwner->FullyLock();
if (mCurrent == NULL) {
mOwner->FullyUnlock();
return E_NO_SUCH_ELEMENT_EXCEPTION;
}
AutoPtr<IInterface> x = mCurrentElement;
mLastRet = mCurrent;
mCurrent = NextNode(mCurrent);
mCurrentElement = (mCurrent == NULL) ? NULL : mCurrent->mItem;
mOwner->FullyUnlock();
*object = x;
INTERFACE_ADDREF(*object);
return NOERROR;
}
ECode CLinkedBlockingQueue::Itr::Remove()
{
if (mLastRet == NULL) return E_ILLEGAL_STATE_EXCEPTION;
mOwner->FullyLock();
AutoPtr<Node> node = mLastRet;
mLastRet = NULL;
for (AutoPtr<Node> trail = mOwner->mHead, p = trail->mNext;
p != NULL;
trail = p, p = p->mNext) {
if (p == node) {
mOwner->Unlink(p, trail);
break;
}
}
mOwner->FullyUnlock();
return NOERROR;
}
CLinkedBlockingQueue::CLinkedBlockingQueue()
: mCapacity(0)
{
ASSERT_SUCCEEDED(CAtomicInteger32::New((IAtomicInteger32**)&mCount));
}
ECode CLinkedBlockingQueue::constructor()
{
return constructor(Elastos::Core::Math::INT32_MAX_VALUE);
}
ECode CLinkedBlockingQueue::constructor(
/* [in] */ Int32 capacity)
{
if (capacity <= 0) return E_ILLEGAL_ARGUMENT_EXCEPTION;
mCapacity = capacity;
mLast = mHead = new Node(NULL);
return NOERROR;
}
ECode CLinkedBlockingQueue::constructor(
/* [in] */ ICollection* c)
{
FAIL_RETURN(constructor(Elastos::Core::Math::INT32_MAX_VALUE));
Mutex::Autolock lock(mPutLock); // Never contended, but necessary for visibility
Int32 n = 0;
AutoPtr< ArrayOf<IInterface*> > elems;
c->ToArray((ArrayOf<IInterface*>**)&elems);
for (Int32 i = 0; i < elems->GetLength(); ++i) {
AutoPtr<IInterface> e = (*elems)[i];
if (e == NULL) return E_NULL_POINTER_EXCEPTION;
if (n == mCapacity) return E_ILLEGAL_STATE_EXCEPTION;
Enqueue(new Node(e));
++n;
}
mCount->Set(n);
return NOERROR;
}
void CLinkedBlockingQueue::SignalNotEmpty()
{
Mutex::Autolock lock(mTakeLock);
mNotEmpty.Signal();
}
void CLinkedBlockingQueue::SignalNotFull()
{
Mutex::Autolock lock(mPutLock);
mNotFull.Signal();
}
void CLinkedBlockingQueue::Enqueue(
/* [in] */ Node* node)
{
// assert putLock.isHeldByCurrentThread();
// assert last.next == null;
mLast = mLast->mNext = node;
}
AutoPtr<IInterface> CLinkedBlockingQueue::Dequeue()
{
// assert takeLock.isHeldByCurrentThread();
// assert head.item == null;
AutoPtr<Node> h = mHead;
AutoPtr<Node> first = h->mNext;
h->mNext = NULL; // help GC
mHead = first;
AutoPtr<IInterface> x = first->mItem;
first->mItem = NULL;
return x;
}
void CLinkedBlockingQueue::FullyLock()
{
mPutLock.Lock();
mTakeLock.Lock();
}
void CLinkedBlockingQueue::FullyUnlock()
{
mTakeLock.Unlock();
mPutLock.Unlock();
}
ECode CLinkedBlockingQueue::GetSize(
/* [out] */ Int32* size)
{
VALIDATE_NOT_NULL(size);
return mCount->Get(size);
}
ECode CLinkedBlockingQueue::RemainingCapacity(
/* [out] */ Int32* capacity)
{
VALIDATE_NOT_NULL(capacity);
Int32 c = -1;
mCount->Get(&c);
*capacity = mCapacity - c;
return NOERROR;
}
ECode CLinkedBlockingQueue::Put(
/* [in] */ IInterface* e)
{
if (e == NULL) return E_NULL_POINTER_EXCEPTION;
// Note: convention in all put/take/etc is to preset local var
// holding count negative to indicate failure unless set.
Int32 c = -1;
AutoPtr<Node> node = new Node(e);
{
// TODO:
// putLock.lockInterruptibly();
Mutex::Autolock lock(mPutLock);
/*
* Note that count is used in wait guard even though it is
* not protected by lock. This works because count can
* only decrease at this point (all other puts are shut
* out by lock), and we (or some other waiting put) are
* signalled if it ever changes from capacity. Similarly
* for all other uses of count in other wait guards.
*/
while (mCount->Get(&c), c == mCapacity) {
mNotFull.Wait(mPutLock);
}
Enqueue(node);
mCount->GetAndIncrement(&c);
if (c + 1 < mCapacity) {
mNotFull.Signal();
}
}
if (c == 0) {
SignalNotEmpty();
}
return NOERROR;
}
ECode CLinkedBlockingQueue::OfferEx(
/* [in] */ IInterface* e,
/* [in] */ Int64 timeout,
/* [in] */ ITimeUnit* unit,
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
if (e == NULL) return E_NULL_POINTER_EXCEPTION;
Int64 nanos;
unit->ToNanos(timeout, &nanos);
Int32 c = -1;
{
// TODO:
// putLock.lockInterruptibly();
Mutex::Autolock lock(mPutLock);
while (mCount->Get(&c), c == mCapacity) {
if (nanos <= 0) {
*result = FALSE;
return NOERROR;
}
mNotFull.WaitNanos(mPutLock, nanos, &nanos);
}
Enqueue(new Node(e));
mCount->GetAndIncrement(&c);
if (c + 1 < mCapacity) {
mNotFull.Signal();
}
}
if (c == 0) {
SignalNotEmpty();
}
*result = TRUE;
return NOERROR;
}
ECode CLinkedBlockingQueue::Offer(
/* [in] */ IInterface* e,
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
if (e == NULL) return E_NULL_POINTER_EXCEPTION;
Int32 c = -1;
if (mCount->Get(&c), c == mCapacity) {
*result = FALSE;
return NOERROR;
}
AutoPtr<Node> node = new Node(e);
{
Mutex::Autolock lock(mPutLock);
if (mCount->Get(&c), c < mCapacity) {
Enqueue(node);
mCount->GetAndIncrement(&c);
if (c + 1 < mCapacity) {
mNotFull.Signal();
}
}
}
if (c == 0) {
SignalNotEmpty();
}
*result = c >= 0;
return NOERROR;
}
ECode CLinkedBlockingQueue::Take(
/* [out] */ IInterface** e)
{
AutoPtr<IInterface> x;
Int32 c = -1;
{
// TODO:
// takeLock.lockInterruptibly();
Mutex::Autolock lock(mTakeLock);
while (mCount->Get(&c), c == 0) {
mNotEmpty.Wait(mTakeLock);
}
x = Dequeue();
mCount->GetAndDecrement(&c);
if (c > 1) {
mNotEmpty.Signal();
}
}
if (c == mCapacity) {
SignalNotFull();
}
*e = x;
INTERFACE_ADDREF(*e);
return NOERROR;
}
ECode CLinkedBlockingQueue::PollEx(
/* [in] */ Int64 timeout,
/* [in] */ ITimeUnit* unit,
/* [out] */ IInterface** e)
{
VALIDATE_NOT_NULL(e);
AutoPtr<IInterface> x;
Int64 nanos;
unit->ToNanos(timeout, &nanos);
Int32 c = -1;
{
// TODO:
// takeLock.lockInterruptibly();
Mutex::Autolock lock(mTakeLock);
while (mCount->Get(&c), c == 0) {
if (nanos <= 0) {
*e = NULL;
return NOERROR;
}
mNotEmpty.WaitNanos(mTakeLock, nanos, &nanos);
}
x = Dequeue();
mCount->GetAndDecrement(&c);
if (c > 1) {
mNotEmpty.Signal();
}
}
if (c == mCapacity) {
SignalNotFull();
}
*e = x;
INTERFACE_ADDREF(*e);
return NOERROR;
}
ECode CLinkedBlockingQueue::Poll(
/* [out] */ IInterface** e)
{
VALIDATE_NOT_NULL(e);
Int32 c = -1;
if (mCount->Get(&c), c == 0) {
*e = NULL;
return NOERROR;
}
AutoPtr<IInterface> x;
{
Mutex::Autolock lock(mTakeLock);
if (mCount->Get(&c), c > 0) {
x = Dequeue();
mCount->GetAndDecrement(&c);
if (c > 1) {
mNotEmpty.Signal();
}
}
}
if (c == mCapacity) {
SignalNotFull();
}
*e = x;
INTERFACE_ADDREF(*e);
return NOERROR;
}
ECode CLinkedBlockingQueue::Peek(
/* [out] */ IInterface** e)
{
VALIDATE_NOT_NULL(e);
Int32 c = -1;
if (mCount->Get(&c), c == 0) {
*e = NULL;
return NOERROR;
}
{
Mutex::Autolock lock(mTakeLock);
AutoPtr<Node> first = mHead->mNext;
if (first == NULL) {
*e = NULL;
return NOERROR;
}
else {
*e = first->mItem;
INTERFACE_ADDREF(*e);
return NOERROR;
}
}
}
void CLinkedBlockingQueue::Unlink(
/* [in] */ Node* p,
/* [in] */ Node* trail)
{
// assert isFullyLocked();
// p.next is not changed, to allow iterators that are
// traversing p to maintain their weak-consistency guarantee.
p->mItem = NULL;
trail->mNext = p->mNext;
if (mLast.Get() == p) {
mLast = trail;
}
Int32 c = -1;
if (mCount->GetAndDecrement(&c), c == mCapacity) {
mNotFull.Signal();
}
}
ECode CLinkedBlockingQueue::Remove(
/* [in] */ IInterface* o,
/* [out] */ Boolean* modified)
{
VALIDATE_NOT_NULL(modified);
if (o == NULL) {
*modified = FALSE;
return NOERROR;
}
FullyLock();
for (AutoPtr<Node> trail = mHead, p = trail->mNext;
p != NULL;
trail = p, p = p->mNext) {
assert(0);
// if (o.equals(p.item)) {
// unlink(p, trail);
// FullyUnlock();
// return true;
// }
}
FullyUnlock();
*modified = FALSE;
return NOERROR;
}
ECode CLinkedBlockingQueue::Contains(
/* [in] */ IInterface* object,
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
if (object == NULL) {
*result = FALSE;
return NOERROR;
}
FullyLock();
for (AutoPtr<Node> p = mHead->mNext; p != NULL; p = p->mNext) {
assert(0);
// if (o.equals(p.item)) {
// FullyUnlock();
// return true;
// }
}
FullyUnlock();
*result = FALSE;
return NOERROR;
}
ECode CLinkedBlockingQueue::ToArray(
/* [out, callee] */ ArrayOf<IInterface*>** array)
{
VALIDATE_NOT_NULL(array);
FullyLock();
Int32 size;
mCount->Get(&size);
AutoPtr< ArrayOf<IInterface*> > a = ArrayOf<IInterface*>::Alloc(size);
Int32 k = 0;
for (AutoPtr<Node> p = mHead->mNext; p != NULL; p = p->mNext) {
a->Set(k++, p->mItem);
}
FullyUnlock();
*array = a;
ARRAYOF_ADDREF(*array);
return NOERROR;
}
ECode CLinkedBlockingQueue::ToArrayEx(
/* [in] */ ArrayOf<IInterface*>* inArray,
/* [out, callee] */ ArrayOf<IInterface*>** outArray)
{
VALIDATE_NOT_NULL(outArray);
FullyLock();
AutoPtr< ArrayOf<IInterface*> > a = inArray;
Int32 size;
mCount->Get(&size);
if (a->GetLength() < size) {
a = ArrayOf<IInterface*>::Alloc(size);
}
Int32 k = 0;
for (AutoPtr<Node> p = mHead->mNext; p != NULL; p = p->mNext) {
a->Set(k++, p->mItem);
}
if (a->GetLength() > k) {
a->Set(k, NULL);
}
FullyUnlock();
*outArray = a;
ARRAYOF_ADDREF(*outArray);
return NOERROR;
}
ECode CLinkedBlockingQueue::Clear()
{
FullyLock();
for (AutoPtr<Node> p, h = mHead; (p = h->mNext) != NULL; h = p) {
h->mNext = NULL;
p->mItem = NULL;
}
mHead = mLast;
// assert head.item == null && head.next == null;
Int32 c = -1;
if (mCount->GetAndSet(0, &c), c == mCapacity) {
mNotFull.Signal();
}
FullyUnlock();
return NOERROR;
}
ECode CLinkedBlockingQueue::DrainTo(
/* [in] */ ICollection* c,
/* [out] */ Int32* number)
{
return DrainToEx(c, Elastos::Core::Math::INT32_MAX_VALUE, number);
}
ECode CLinkedBlockingQueue::DrainToEx(
/* [in] */ ICollection* c,
/* [in] */ Int32 maxElements,
/* [out] */ Int32* number)
{
VALIDATE_NOT_NULL(number);
if (c == NULL) return E_NULL_POINTER_EXCEPTION;
if (c == ICollection::Probe(this)) return E_ILLEGAL_ARGUMENT_EXCEPTION;
if (maxElements <= 0) {
*number = 0;
return NOERROR;
}
Boolean signalNotFull = FALSE;
mTakeLock.Lock();
Int32 size;
mCount->Get(&size);
Int32 n = Elastos::Core::Math::Min(maxElements, size);
// count.get provides visibility to first n Nodes
AutoPtr<Node> h = mHead;
Int32 i = 0;
while (i < n) {
AutoPtr<Node> p = h->mNext;
Boolean result;
c->Add(p->mItem, &result);
p->mItem = NULL;
h->mNext = NULL;
h = p;
++i;
}
// Restore invariants even if c.add() threw
if (i > 0) {
// assert h.item == null;
mHead = h;
signalNotFull = (mCount->GetAndAdd(-i, &size), size == mCapacity);
}
mTakeLock.Unlock();
if (signalNotFull) {
SignalNotFull();
}
*number = n;
return NOERROR;
}
ECode CLinkedBlockingQueue::GetIterator(
/* [out] */ IIterator** it)
{
VALIDATE_NOT_NULL(it);
*it = (IIterator*)new Itr(this);
INTERFACE_ADDREF(*it);
return NOERROR;
}
ECode CLinkedBlockingQueue::Add(
/* [in] */ IInterface* object,
/* [out] */ Boolean* modified)
{
FAIL_RETURN(Offer(object, modified));
if (*modified == TRUE) return NOERROR;
else return E_ILLEGAL_STATE_EXCEPTION;
}
ECode CLinkedBlockingQueue::RemoveEx(
/* [out] */ IInterface** e)
{
FAIL_RETURN(Poll(e));
if (*e != NULL) return NOERROR;
else return E_NO_SUCH_ELEMENT_EXCEPTION;
}
ECode CLinkedBlockingQueue::Element(
/* [out] */ IInterface** e)
{
FAIL_RETURN(Peek(e));
if (*e != NULL) return NOERROR;
else return E_NO_SUCH_ELEMENT_EXCEPTION;
}
ECode CLinkedBlockingQueue::AddAll(
/* [in] */ ICollection* c,
/* [out] */ Boolean* modified)
{
VALIDATE_NOT_NULL(modified);
if (c == NULL) return E_NULL_POINTER_EXCEPTION;
if (c == ICollection::Probe(this)) return E_ILLEGAL_ARGUMENT_EXCEPTION;
*modified = FALSE;
AutoPtr< ArrayOf<IInterface*> > elems;
c->ToArray((ArrayOf<IInterface*>**)&elems);
for (Int32 i = 0; i < elems->GetLength(); ++i) {
AutoPtr<IInterface> e = (*elems)[i];
Boolean result = FALSE;
if (Add(e, &result), result) *modified = TRUE;
}
return NOERROR;
}
ECode CLinkedBlockingQueue::ContainsAll(
/* [in] */ ICollection* collection,
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
AutoPtr<IIterator> it;
collection->GetIterator((IIterator**)&it);
Boolean hasNext;
while (it->HasNext(&hasNext), hasNext) {
AutoPtr<IInterface> e;
it->Next((IInterface**)&e);
Boolean contains;
if (Contains(e, &contains), !contains) {
*result = FALSE;
return NOERROR;
}
}
*result = TRUE;
return NOERROR;
}
ECode CLinkedBlockingQueue::IsEmpty(
/* [out] */ Boolean* result)
{
VALIDATE_NOT_NULL(result);
Int32 size;
GetSize(&size);
*result = size == 0;
return NOERROR;
}
ECode CLinkedBlockingQueue::RemoveAll(
/* [in] */ ICollection* collection,
/* [out] */ Boolean* modified)
{
VALIDATE_NOT_NULL(modified);
*modified = FALSE;
AutoPtr<IIterator> it;
GetIterator((IIterator**)&it);
Boolean hasNext;
while (it->HasNext(&hasNext), hasNext) {
AutoPtr<IInterface> e;
it->Next((IInterface**)&e);
Boolean contains;
if (collection->Contains(e, &contains), contains) {
it->Remove();
*modified = TRUE;
}
}
return NOERROR;
}
ECode CLinkedBlockingQueue::RetainAll(
/* [in] */ ICollection* collection,
/* [out] */ Boolean* modified)
{
VALIDATE_NOT_NULL(modified)
*modified = FALSE;
AutoPtr<IIterator> it;
GetIterator((IIterator**)&it);
Boolean hasNext;
while (it->HasNext(&hasNext), hasNext) {
AutoPtr<IInterface> e;
it->Next((IInterface**)&e);
Boolean contains;
if (collection->Contains(e, &contains), !contains) {
it->Remove();
*modified = TRUE;
}
}
return NOERROR;
}
ECode CLinkedBlockingQueue::Equals(
/* [in] */ IInterface* object,
/* [out] */ Boolean* result)
{
assert(0);
return E_NOT_IMPLEMENTED;
}
ECode CLinkedBlockingQueue::GetHashCode(
/* [out] */ Int32* hashCode)
{
assert(0);
return E_NOT_IMPLEMENTED;
}
} // namespace Concurrent
} // namespace Utility
} // namespace Elastos
|
[
"[email protected]"
] | |
347d1e8ab8064cc120e20a04449334c93dc9a6f7
|
868589332469e76d42a7bfbc5211a9f9992ea811
|
/ftl2.0/ftl2.0/SistSegInterno.cpp
|
ea06adb67d8b693e44c00f24356df15da3c3d66d
|
[] |
no_license
|
AdriDelegado/peloamordedeus
|
9dd02165a0ff79a83d5d294ad8139e5ffd577947
|
17cf6aabed80cbd5d0293fd9cf64a08346fe7bd7
|
refs/heads/master
| 2021-01-13T00:45:13.937484 | 2016-01-23T22:36:15 | 2016-01-23T22:36:15 | 50,240,825 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,280 |
cpp
|
#include "SistSegInterno.h"
SistSegInterno::SistSegInterno(string nome, int posicao) : Sala(nome, posicao, 8){} // contrutor
SistSegInterno::~SistSegInterno(void){} //destrutor
SistSegInterno::SistSegInterno(){}
void SistSegInterno::setNivelEscudo(int nivelEscudo) { }
int SistSegInterno::getNivelEscudo() { return 0; }
void SistSegInterno::setNivelEscudoActual(int nivelEscudoActual) { }
int SistSegInterno::getNivelEscudoActual() { return 0; }
bool SistSegInterno::verificaId(string id){
for (int i = 0; i != unidades.size(); i++){
if (unidades.at(i)->getId() == id){
return true;
}
}
return false;
}
string SistSegInterno::setUnidade(Unidade *u) {
if (u != NULL && verificaId(u->getId()) == false){
unidades.push_back(u);
}
else{
return "Unidade com ID " + u->getId() + " escolhida ja esta ocupada";
delete(u);
}
return "Sala " + u->getNome() + " introduzida com Sucasso";
}
vector<int> SistSegInterno::getAdjacenteSala()
{
return this->adjacentes;
}
void SistSegInterno::setAdjacenteSala()
{
if (this->posicao == 1)
{
adjacentes.push_back(2);
}
else if (this->posicao == 2)
{
adjacentes.push_back(1);
adjacentes.push_back(3);
adjacentes.push_back(5);
}
else if (this->posicao == 3)
{
adjacentes.push_back(2);
adjacentes.push_back(4);
adjacentes.push_back(6);
}
else if (this->posicao == 4)
{
adjacentes.push_back(3);
adjacentes.push_back(7);
}
else if (this->posicao == 5)
{
adjacentes.push_back(2);
adjacentes.push_back(6);
adjacentes.push_back(10);
}
else if (this->posicao == 6)
{
adjacentes.push_back(3);
adjacentes.push_back(5);
adjacentes.push_back(7);
adjacentes.push_back(11);
}
else if (this->posicao == 7)
{
adjacentes.push_back(4);
adjacentes.push_back(6);
adjacentes.push_back(8);
adjacentes.push_back(12);
}
else if (this->posicao == 8)
{
adjacentes.push_back(7);
}
else if (this->posicao == 9)
{
adjacentes.push_back(10);
}
else if (this->posicao == 10)
{
adjacentes.push_back(5);
adjacentes.push_back(9);
adjacentes.push_back(11);
}
else if (this->posicao == 11)
{
adjacentes.push_back(6);
adjacentes.push_back(10);
adjacentes.push_back(12);
}
else if (this->posicao == 12)
{
adjacentes.push_back(7);
adjacentes.push_back(11);
}
}
|
[
"[email protected]"
] | |
4b6e2d9dadac4f3f11925694d4010df83db128e6
|
89647394f22605d8d23a25873ceb4eda2a249c47
|
/Data Structure/Multiset/multiset.lower_bound.cpp
|
57b5f3587a9f529a6997979702851626ce50e3cb
|
[] |
no_license
|
BaeJi77/data_structure
|
29f6713d693b859b9832bb420b06ba913d9fc12e
|
1f89141a4f60e4970addfaf505b05e05da18e01f
|
refs/heads/master
| 2020-03-24T02:59:39.616065 | 2018-11-01T12:39:56 | 2018-11-01T12:39:56 | 142,399,603 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 928 |
cpp
|
//
// multiset_equl_range.cpp
// Data Structure
//
// Created by Hoon on 2018. 7. 26..
// Copyright © 2018년 Hoon. All rights reserved.
// 출처 : http://www.cplusplus.com/reference/set/multiset/lower_bound/
// multiset::lower_bound/upper_bound
#include <iostream>
#include <set>
int main ()
{
std::multiset<int> mymultiset;
std::multiset<int>::iterator itlow,itup;
for (int i=1; i<8; i++) mymultiset.insert(i*10); // 10 20 30 40 50 60 70
itlow = mymultiset.lower_bound (30); // ^
itup = mymultiset.upper_bound (40); // ^
printf("%d %d\n" , *itlow , *itup); // 30 50
// mymultiset.erase(itlow,itup); // 10 20 50 60 70
std::cout << "mymultiset contains:";
for (std::multiset<int>::iterator it=itlow; it!=itup; ++it)
std::cout << ' ' << *it;
std::cout << '\n';
return 0;
}
|
[
"[email protected]"
] | |
073c2ba3486233c4b0a7b384651fcd72e6e25893
|
f140c8a41f2218635eb388e5996d2a72d74b2ca9
|
/HAPI_Start/Controller_Slime.cpp
|
5a3f60824edc75f8a94a386e211faec2f865c6e9
|
[] |
no_license
|
ryannowen/GEC
|
dcb8375a5bf9a47765e9f9162e21cd8abfd8c3af
|
2bfb4ce1332cde8aab994ef0026b8115e781fe2e
|
refs/heads/master
| 2022-04-09T16:53:12.613887 | 2020-03-15T16:51:46 | 2020-03-15T16:51:46 | 224,272,142 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,243 |
cpp
|
#include "Controller_Slime.h"
#include "Slime.h"
#include "World.h"
void Controller_Slime::Update(Entity& argEntity, const unsigned int argPlayerID)
{
Slime* slime = static_cast<Slime*>(&argEntity);
if (slime->isPossessed) /// Player
{
const HAPI_TControllerData& controllerData{ HAPI.GetControllerData(argPlayerID) };
if (slime->isAttacking)
return;
if (controllerData.isAttached) /// Controller
{
Vector2<float> dir{ GetMovementDirection(argPlayerID) };
if (controllerData.digitalButtons[controllerInput[3]])
{
if (slime->canAttack && !slime->isCharging)
{
slime->Attack();
UpdateAnimDir(EAction::eAttackRight, EAction::eAttackLeft);
}
}
else if (static_cast<int>(dir.x) > 0 && !slime->isCharging)
controllerAction = EAction::eMoveRight;
else if (static_cast<int>(dir.x) < 0 && !slime->isCharging)
controllerAction = EAction::eMoveLeft;
else
UpdateAnimDir(EAction::eIdleRight, EAction::eIdleLeft);
}
else /// Keyboard
{
const HAPI_TKeyboardData& keyboardData{ HAPI.GetKeyboardData() };
if (keyboardData.scanCode[keyboardInput[5]])
{
if (slime->canAttack && !slime->isCharging)
{
slime->Attack();
UpdateAnimDir(EAction::eAttackRight, EAction::eAttackLeft);
}
}
else if (keyboardData.scanCode[keyboardInput[2]] && !slime->isCharging)
controllerAction = EAction::eMoveRight;
else if (keyboardData.scanCode[keyboardInput[3]] && !slime->isCharging)
controllerAction = EAction::eMoveLeft;
else
UpdateAnimDir(EAction::eIdleRight, EAction::eIdleLeft);
}
}
else /// AI
{
const std::shared_ptr<Entity>& player{ WORLD.GetPlayer() };
const Vector2<float> dir{player->GetPosition() - slime->currentPosition };
const float dist{ dir.Dot() };
if (dist > 32 && !slime->isCharging && !slime->isAttacking)
{
if (dir.x > 0)
controllerAction = EAction::eMoveRight;
else
controllerAction = EAction::eMoveLeft;
}
else if (slime->canAttack && !slime->isAttacking && dist < 32)
{
slime->Attack();
UpdateAnimDir(EAction::eAttackRight, EAction::eAttackLeft);
}
else if (!slime->isAttacking || slime->isCharging)
{
UpdateAnimDir(EAction::eIdleRight, EAction::eIdleLeft);
}
}
}
|
[
"[email protected]"
] | |
e3dd9ddaca477c46c549f47fc075e884f6171889
|
81dfe750f761728e74525b5b5083861ef958fc4e
|
/arg/dna/cRoadmapBuilder.h
|
dbe2bde86f73b745eede8af152cc0e49679a644d
|
[] |
no_license
|
foowie/my-velvet
|
a64eb111ffa5106bf90c61cde1ffb710231044fb
|
be381c06e023026e7ee12e3a04414c8142b710cc
|
refs/heads/master
| 2020-04-16T10:38:26.365604 | 2013-07-04T14:41:19 | 2013-07-04T14:41:19 | 10,336,924 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,471 |
h
|
/*
* File: cRoadmapBuilder.h
* Author: Daniel Robenek
*
* Created on 29. květen 2013, 22:09
*/
#include <iostream>
#include "BaseTypes.h"
#include "cKmerOccurenceMap.h"
#include "cKmerBuilder.h"
#ifndef CROADMAPBUILDER_H
#define CROADMAPBUILDER_H
namespace arg {
namespace dna {
class cRoadmapBuilder {
private:
cKmerBuilder * kmerBuilder;
cKmerOccurenceMap * map;
unsigned short offset;
cKmerOccurencePosition * firstKmerOccurence;
unsigned short foundLength;
bool found;
cKmerOccurencePosition * position;
public:
cRoadmapBuilder(cKmerBuilder & pKmerBuilder, cKmerOccurenceMap & pMap) :
kmerBuilder(&pKmerBuilder), map(&pMap) {
offset = 0;
firstKmerOccurence = NULL;
foundLength = 0;
found = false;
}
void Build() {
while (kmerBuilder->Next()) {
if (kmerBuilder->GetLineChanged()) {
ProcessEndline();
}
const Kmer kmer = kmerBuilder->GetKmer();
position = map->GetPosition(kmer);
if (position == NULL) {
found = false;
map->Add(kmer, kmerBuilder->GetCurrentLine().index, offset);
} else {
foundLength++;
found = true;
}
bool continuesOnLastFoundKmer = foundLength > 1 && found && firstKmerOccurence->line == position->line && firstKmerOccurence->offset + foundLength - 1 == position->offset;
if (found && foundLength > 1 && !continuesOnLastFoundKmer) {
foundLength--;
ProcessRoadmap();
firstKmerOccurence = position;
foundLength = 1;
} else if (found && foundLength > 1 /* && continuesOnLastFoundKmer*/) {
} else if (!found && foundLength > 0) {
ProcessRoadmap();
++offset;
firstKmerOccurence = NULL;
foundLength = 0;
} else if (found /* && foundLength <= 1*/) {
firstKmerOccurence = position;
} else /* if !found && foundLength <= 1*/ {
++offset;
firstKmerOccurence = NULL;
foundLength = 0;
}
}
if (found) {
ProcessRoadmap();
}
}
private:
inline void ProcessEndline() {
if (found) {
ProcessRoadmap();
}
found = false;
foundLength = 0;
offset = 0;
firstKmerOccurence = NULL;
printf("ROADMAP %u\n", kmerBuilder->GetCurrentLine().index);
}
inline void ProcessRoadmap() {
printf("%u\t%u\t%u\t%u\n", firstKmerOccurence->line, offset, firstKmerOccurence->offset, firstKmerOccurence->offset + foundLength);
}
};
}
}
#endif /* CROADMAPBUILDER_H */
|
[
"[email protected]"
] | |
1b0ed71c1e211b8ff0711087a379dfe22c384081
|
b24bf3df556ed16243a50d0e5d7263971502d7f2
|
/Homework 08.11.17/Task 1/Task 1.cpp
|
35d5cd0cfbde50e0408058bf7ec7adb6d433640c
|
[] |
no_license
|
SkybskiMax/BSUsemesterOne
|
f57e82a5532e2a09954e185eb6fe61e7cde3e23c
|
4a15ebbf36d30d24646fada6453787303af3bbf6
|
refs/heads/master
| 2021-09-10T04:31:44.903089 | 2018-01-05T09:33:29 | 2018-01-05T09:33:29 | 109,843,977 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 255 |
cpp
|
#include <iostream>;
#include "ArrayFunc.h";
using namespace std;
int main()
{
const int N = 100;
int array[N];
int range = 100;
GenerateRandomArray(array, N, range);
SortBubbleArray(array, N);
DisplayArray(array, N);
system("pause");
return 0;
}
|
[
"[email protected]"
] | |
f6e8757cc8ae4a1b6ed55a517f2ae294b981048b
|
c58491ae7b1ad20f28f0d28d2ebf9dcd3b78d0a0
|
/labwork1/labwork1/main.cpp
|
90aaf0f0bee6c4049e66879aaef6fd5763547fa3
|
[] |
no_license
|
LusianaDiyan/algoritma-struktur-data
|
28d172c69ddb9a4e6583bc42bd84d3c6a413c833
|
71860d5192c20790ceadb0cf6507a22a59af87ba
|
refs/heads/master
| 2022-09-16T12:25:32.845975 | 2020-06-06T05:19:51 | 2020-06-06T05:19:51 | 237,813,828 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 2,016 |
cpp
|
//#include "pch.h"
#include <iostream>
#include <fstream>
#include <string>
#include <string.h>
#include <cstdio>
#include <stdlib.h>
#include <vector>
#include <cstdlib>
#include "OperationFile.h"
#include <stdlib.h>
using namespace std;
int main() {
string lokasi = "D:\\ASDAT\\lusi.xml";
printf_s("Masukkan Nama : ");
string nama,nrp;
cin >> nama;
printf_s("Masukkan NRP : ");
cin >> nrp;
OperationFile op;
//op.OverwriteToFile(lokasi, "");
// Write to file untuk memasukkan data dengan tidak menghapus data lama
op.WriteToFile(lokasi, "<mahasiswa>\n\t<nama>" + nama + "</nama>\n\t<nrp>" + nrp +"</nrp>\n</mahasiswa>\n");
// Print to screen untuk menampilkan data dari lokasi yang telah di tentukan
op.printToScreen(lokasi);
//op.printXMLToScreen(lokasi, "nrp");
//string file = op.getFile(lokasi);
//vector<string> data = op.getData(file,"mahasiswa");
/*for (size_t i = 0; i < data.size(); i++)
{
cout << data[i];
}*/
/*
op.printToScreen("D:\\ASDAT\\lusi.txt");
op.WriteToFile("D:\\ASDAT\\lusi.txt", "abc");
op.printToScreen("D:\\ASDAT\\lusi.txt");
*/
//Memindah file
char oldname[] = "D:\\ASDAT\\lusi.xml";
char newname[] = "D:\\ASDAT\\lusi.xml";
//op.OverwriteToFile("D:\\ASDAT\\lusi.xml", "say hi to me");
op.moveFile(oldname, newname);
system("pause");
}
// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
// Debug program: F5 or Debug > Start Debugging menu
// Tips for Getting Started:
// 1. Use the Solution Explorer window to add/manage files
// 2. Use the Team Explorer window to connect to source control
// 3. Use the Output window to see build output and other messages
// 4. Use the Error List window to view errors
// 5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
// 6. In the future, to open this project again, go to File > Open > Project and select the .sln file
|
[
"[email protected]"
] | |
175b6e1a2d34ce8a525b44479e3c75f410f16068
|
8e397542b84257e91ef30ba43a417fcbf7edb5cc
|
/DataStructures/DoubleLinkedListNode.h
|
b1654c0e0410daf8f9ca1a2eaeb43d820bced64e
|
[] |
no_license
|
JoseVillalta/Data-Structures-and-Algorithms-in-C-
|
3ed801f5628ebee58bbefba50a6583aa7afcfa56
|
9a1e4cda3da7f077eaca2391cc2d4418da1e243f
|
refs/heads/master
| 2020-05-22T04:14:18.746431 | 2018-02-22T15:26:27 | 2018-02-22T15:26:27 | 48,241,381 | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 254 |
h
|
#pragma once
#include "LinkedListNode.h"
template <typename T>
class DListNode
{
public:
T data;
DListNode * prev;
DListNode * next;
DListNode(T val = 0)
{
data = val;
prev = nullptr;
next = nullptr;
}
};
|
[
"[email protected]"
] | |
1fec783ca16c2883ee2586baf633d47fc66e67f1
|
0f7a4119185aff6f48907e8a5b2666d91a47c56b
|
/sstd_utility/windows_boost/boost/compute/interop/vtk.hpp
|
e40cd7c41c401e9b4d1eb549b4acf1f69c481b24
|
[] |
no_license
|
jixhua/QQmlQuickBook
|
6636c77e9553a86f09cd59a2e89a83eaa9f153b6
|
782799ec3426291be0b0a2e37dc3e209006f0415
|
refs/heads/master
| 2021-09-28T13:02:48.880908 | 2018-11-17T10:43:47 | 2018-11-17T10:43:47 | null | 0 | 0 | null | null | null | null |
UTF-8
|
C++
| false | false | 765 |
hpp
|
//---------------------------------------------------------------------------//
// Copyright (c) 2013-2014 Kyle Lutz <[email protected]>
//
// Distributed under the Boost Software License, Version 1.0
// See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt
//
// See http://boostorg.github.com/compute for more information.
//---------------------------------------------------------------------------//
#ifndef BOOST_COMPUTE_INTEROP_VTK_HPP
#define BOOST_COMPUTE_INTEROP_VTK_HPP
#include <boost/compute/interop/vtk/bounds.hpp>
#include <boost/compute/interop/vtk/data_array.hpp>
#include <boost/compute/interop/vtk/matrix4x4.hpp>
#include <boost/compute/interop/vtk/points.hpp>
#endif // BOOST_COMPUTE_INTEROP_VTK_HPP
|
[
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.