|
Apache log4cxx
Version 0.10.0
|
An abstract representation of file and directory path names. More...
Public Member Functions | |
| File () | |
| Construct a new instance. More... | |
| File (const char *path) | |
| Construct a new instance. More... | |
| File (const std::string &path) | |
| Construct a new instance. More... | |
| File (const wchar_t *path) | |
| Construct a new instance. More... | |
| File (const std::wstring &path) | |
| Construct a new instance. More... | |
| File (const UniChar *path) | |
| Construct a new instance. More... | |
| File (const std::basic_string< UniChar > &path) | |
| Construct a new instance. More... | |
| File (const CFStringRef &path) | |
| Construct a new instance. More... | |
| File (const File &src) | |
| Copy constructor. More... | |
| File & | operator= (const File &src) |
| Assignment operator. More... | |
| ~File () | |
| Destructor. More... | |
| bool | exists (log4cxx::helpers::Pool &p) const |
| Determines if file exists. More... | |
| size_t | length (log4cxx::helpers::Pool &p) const |
| Determines length of file. More... | |
| log4cxx_time_t | lastModified (log4cxx::helpers::Pool &p) const |
| Determines last modification date. More... | |
| LogString | getName () const |
| Get final portion of file path. More... | |
| LogString | getPath () const |
| Get file path. More... | |
| File & | setPath (const LogString &) |
| Set file path. More... | |
| log4cxx_status_t | open (apr_file_t **file, int flags, int perm, log4cxx::helpers::Pool &p) const |
| Open file. More... | |
| std::vector< LogString > | list (log4cxx::helpers::Pool &p) const |
| List files if current file is a directory. More... | |
| bool | deleteFile (log4cxx::helpers::Pool &p) const |
| Delete file. More... | |
| bool | renameTo (const File &dest, log4cxx::helpers::Pool &p) const |
| Rename file. More... | |
| LogString | getParent (log4cxx::helpers::Pool &p) const |
| Get path of parent directory. More... | |
| bool | mkdirs (log4cxx::helpers::Pool &p) const |
| Make directories recursively. More... | |
An abstract representation of file and directory path names.
| File | ( | ) |
Construct a new instance.
| File | ( | const char * | path | ) |
Construct a new instance.
Use setPath to specify path using a LogString.
| path | file path in local encoding. |
| File | ( | const std::string & | path | ) |
Construct a new instance.
Use setPath to specify path using a LogString.
| path | file path in current encoding. |
| File | ( | const wchar_t * | path | ) |
Construct a new instance.
Use setPath to specify path using a LogString.
| path | file path. |
| File | ( | const std::wstring & | path | ) |
Construct a new instance.
Use setPath to specify path using a LogString.
| path | file path. |
Construct a new instance.
Use setPath to specify path using a LogString.
| path | file path. |
Construct a new instance.
Use setPath to specify path using a LogString.
| path | file path. |
| File | ( | const CFStringRef & | path | ) |
Construct a new instance.
Use setPath to specify path using a LogString.
| path | file path. |
| ~File | ( | ) |
Destructor.
| bool deleteFile | ( | log4cxx::helpers::Pool & | p | ) | const |
Delete file.
| p | pool. |
| bool exists | ( | log4cxx::helpers::Pool & | p | ) | const |
Determines if file exists.
| p | pool. |
| LogString getName | ( | ) | const |
Get final portion of file path.
| LogString getParent | ( | log4cxx::helpers::Pool & | p | ) | const |
Get path of parent directory.
| p | pool. |
| LogString getPath | ( | ) | const |
Get file path.
| log4cxx_time_t lastModified | ( | log4cxx::helpers::Pool & | p | ) | const |
Determines last modification date.
| p | pool. |
| size_t length | ( | log4cxx::helpers::Pool & | p | ) | const |
Determines length of file.
May not be accurate if file is current open.
| p | pool. |
| std::vector<LogString> list | ( | log4cxx::helpers::Pool & | p | ) | const |
List files if current file is a directory.
| p | pool. |
| bool mkdirs | ( | log4cxx::helpers::Pool & | p | ) | const |
Make directories recursively.
| p | pool. |
| log4cxx_status_t open | ( | apr_file_t ** | file, |
| int | flags, | ||
| int | perm, | ||
| log4cxx::helpers::Pool & | p | ||
| ) | const |
Open file.
See apr_file_open for details.
| file | APR file handle. |
| flags | flags. |
| perm | permissions. |
| p | pool. |
| bool renameTo | ( | const File & | dest, |
| log4cxx::helpers::Pool & | p | ||
| ) | const |
Rename file.
| dest | new path for file. |
| p | pool. |


Before Change
// GH 19101: empty result, different dtypes -> common dtype is object
other = empty_index(dtype="float64", closed=closed)
result = index.union(other, sort=sort)
expected = Index([], dtype=object)
tm.assert_index_equal(result, expected)
def test_intersection(self, closed, sort):
index = monotonic_index(0, 11, closed=closed)
After Change
other = index.union(index, sort=sort)
tm.assert_index_equal(result, expected)
other = empty_index(dtype="uint64", closed=closed)
result = index.union(other, sort=sort)
tm.assert_index_equal(result, expected)
result = other.union(index, sort=sort)
tm.assert_index_equal(result, expected)


COLOR OF NIGHT A film review by Jason Langlois Copyright 1994 Jason Langlois
This is an eminently predictable film, with nothing much to redeem it. I'd suggest waiting for it to come out on video, or even not watching it at all.
The premise is a simple (and of late, often used) one. Bruce Willis plays a New York psychotherapist who has a patient commit suicide before his eyes. Faced with a lawsuit, and his own emotional troubles stemming from the incident (he can no longer see the color red--I suspect the backers of this film won't have this problem), he resigns his practice and travels to Los Angeles after bidding farewell to his elderly mentor. There, he finds himself drawn into an ersatz thriller.
Arriving in LA, he meets with a college chum who is also a successful psychotherapist, and sits in with a Monday support group. In conversation with this friend (played by Scott Bakula, late of "Quantum Leap") the next day, he finds out that someone from the group has been making death threats against his friend. Sure enough, later that evening, the friend is horribly murdered in his office.
Introduce the blustering cop (Ruben Blades), the mysterious and gorgeous young woman (Jane March), and the collection of potential killers. While it is hard to point to the direct similarities to FINAL ANALYSIS, watching this film constantly made me think of it. Fondly. (Yes, that's how bad this movie is.) Bruce Willis' character takes over his friend's practice, and also becomes an amateur sleuth trying to figure out which of the disturbed patients could have killed his friend.
Are there any virtues in this film? Brad Dourif's portrayal of an Obsessive-Compulsive is fun to watch. Ruben Blades is also effective as the police detective (I kept wanting the film to be about him). They aren't, however, worth the price of this film. It's not the acting, but the writing, that is the death knell of this movie.
From the audience response, this movie does have some appeal. The appeal seems to center on the rare one-liner that Bruce manages to put in, and the enjoyment Ruben Blades' character brings to the screen. Really, skip this film. If you have to watch it, make it on video and you'll be much happier. For complete happiness, just avoid seeing it at all.
-- Jason Langlois<EMAIL_ADDRESS>MYRA Systems Corp.
.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Maksim, developer of ClickHouse.
1. JIT basics
2. LLVM instruments
3. ClickHouse compilation of expressions
4. ClickHouse compilation of operator GROUP BY
JIT - Just in time compilation
Generate machine code and execute in runtime.
Examples: JVM Hotspot, V8.
int64_t sum(int64_t value_1, int64_t value_2)
{
return value_1 + value_2;
}
int main(int argc, char ** argv)
{
printf("Sum %ld\n", sum(1, 2));
return 0;
}
$ g++ -O2 jit_example.cpp -o jit_example
$ objdump -D jit_example | grep sum -A5
0000000000001180 <_Z3sumll>:
1180: f3 0f 1e fa endbr64
1184: 48 8d 04 37 lea (%rdi,%rsi,1),%rax /// %rax = %rdi * %rsi + 1
1188: c3 retq
1189: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
https://en.wikipedia.org/wiki/X86_calling_conventions#System_V_AMD64_ABI
https://en.wikipedia.org/wiki/Executable_and_Linkable_Format
$ readelf -S jit_example
There are 31 section headers, starting at offset 0x39a8:
Section Headers:
[16] .text PROGBITS<PHONE_NUMBER>001060 00001060
00000000000001a5<PHONE_NUMBER>000000 AX 0 0 16
[18] .rodata PROGBITS<PHONE_NUMBER>002000 00002000
000000000000000d<PHONE_NUMBER>000000 A 0 0 4
[25] .data PROGBITS<PHONE_NUMBER>004000 00003000
0000000000000010<PHONE_NUMBER>000000 WA 0 0 8
Key to Flags:
W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
L (link order), O (extra OS processing required), G (group), T (TLS),
C (compressed), x (unknown), o (OS specific), E (exclude),
l (large), p (processor specific)
printf("Sum %ld\n", sum(1, 2));
$ readelf -x .rodata jit_example
Hex dump of section '.rodata':
0x00002000 01000200 53756d20 256c640a 00 ....Sum %ld..
$ objdump -D jit_example | grep sum -A5
0000000000001180 <_Z3sumll>:
1180: f3 0f 1e fa endbr64
1184: 48 8d 04 37 lea (%rdi,%rsi,1),%rax
1188: c3 retq
1189: 0f 1f 80 00 00 00 00 nopl 0x0(%rax)
$ readelf -x .text jit_example
Hex dump of section '.text':
0x00001060 f30f1efa 4883ec08 ba030000 00bf0100 ....H...........
...
0x00001180 f30f1efa 488d0437 c30f1f80 00000000 ....H..7........
0x00001190 f30f1efa 41574c8d 3d1b2c00 00415649 ....AWL.=.,..AVI
0x000011a0 89d64155 4989f541 544189fc 55488d2d ..AUI..ATA..UH.-
...
0x00001200 f30f1efa c3 ....
1144: 48 8d 04 37 lea (%rdi,%rsi,1),%rax
1148: c3 retq
int64_t jitSum(int64_t value_1, int64_t value_2)
{
/// Allocate page with READ + WRITE + EXEC permissions
char * res = static_cast(mmap(NULL, 4096, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANON, -1, 0));
size_t instruction = 0;
/// lea (%rdi, %rsi, 1), %rax => rax = rdi + rsi * 1
res[instruction++] = 0x48;
res[instruction++] = 0x8d;
res[instruction++] = 0x04;
res[instruction++] = 0x37;
/// retq
res[instruction++] = 0xc3;
using SumFunction = int64_t (*)(int64_t, int64_t);
SumFunction func = reinterpret_cast<SumFunction>(res);
return func(value_1, value_2);
}
int main(int argc, char ** argv)
{
printf("Sum %ld\n", jitSum(1, 2));
return 0;
}
$ g++ -O2 jit_example.cpp -o jit_example
$ ./jit_example
$ Sum 3
void test_function()
{
printf("JIT example\n");
}
void jitTestFuncCall()
{
/// Allocate page with READ + WRITE + EXEC permissions
char * res = static_cast<char *>(mmap(NULL, 4096, PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANON, -1, 0));
size_t instruction = 0;
/// movabs [value], %rax
res[instruction++] = 0x48;
res[instruction++] = 0xb8;
ptrdiff_t test_function_raw_ptr = reinterpret_cast(test_function);
memcpy(res + instruction, &test_function_raw_ptr, sizeof(ptrdiff_t));
instruction += sizeof(ptrdiff_t);
/// callq *%rax
res[instruction++] = 0xff;
res[instruction++] = 0xd0;
/// retq
res[instruction++] = 0xc3;
using VoidFunction = void (*)(void);
VoidFunction func = reinterpret_cast<VoidFunction>(res);
func();
}
$ g++ -O2 jit_example.cpp -o jit_example
$ ./jit_example
$ JIT example
1. Optimizing compiler (passes can be configured).
2. Dynamic Linker. Resolve relocations. Allocate necessary code, data sections.
3. Allow to write code in LLVM IR (High level assembler).
4. LLVM tooling IRPrinters, AssemblyPrinters. JIT tooling gdb, perf support.
5. MCJIT, ORCJIT JIT compilers
1. Static Single Assignment (SSA). Variable is assigned only once.
2. Strongly typed.
3. Allows to map high level into low level.
/usr/bin/clang-12 -S -emit-llvm jit_example.cpp
; Function Attrs: noinline nounwind optnone uwtable mustprogress
define dso_local i64 @_Z3sumll(i64 %0, i64 %1) #0 {
%3 = alloca i64, align 8 /// alloca - Allocate memory on stack
%4 = alloca i64, align 8
store i64 %0, i64* %3, align 8 /// store - store value in pointer
store i64 %1, i64* %4, align 8
%5 = load i64, i64* %3, align 8 /// load - load value from pointer
%6 = load i64, i64* %4, align 8
%7 = add nsw i64 %5, %6 /// nsw - No Signed Wrap
ret i64 %7
}
TargetMachine MCContext LLVMContext IRBuilder Module Function BasicBlock PassManagerBuilder PassManager FunctionPassManager ObjectFile RTDyldMemoryManager JITSymbolResolver
TargetMachine — machine target specific information. Allowed CPU instructions, data layout, etc.
LLVMContext — context for global data and LLVM types
IRBuilder — builder for LLVM IR.
Module — container for functions.
Function — function container for BasicBlocks.
BasicBlock — container for LLVM IR instructions executed sequentially without branches except to exit.
PassManagerBuilder — builder for optimization passes.
PassManager — module passes.
FunctionPassManager — function passes.
ObjectFile — object file.
RuntimeDyld — dynamic linker. Takes object file and start dynamic linking, allocate and fill code and data sections. resolve relocations.
RTDyldMemoryManager — dynamic linker memory manager. Allocates necessary code, data sections during linking.
JITSymbolResolver — resolve external symbols during dynamic linking.
1. Create IRModule and fill it with IRFunctions. Apply optimizations using PassManagerBuilder, FunctionPassManager, PassManager.
2. Setup passes in PassManager to emit ObjectFile using TargetMachine and MCContext.
3. Create JITSymbolResolver for resolving external symbols. Example: memset.
4. Create RTDyldMemoryManager for dynamic linker.
5. Resolve relocations and create necessary code, data sections for ObjectFile using RuntimeDyld.
6. Get function symbols from compiled code using RuntimeDyld.
class CHJIT
{
struct CompiledModule
{
/// Size of compiled module code in bytes
size_t size;
/// Module identifier. Should not be changed by client
uint64_t identifier;
/// Map of compiled functions. Should not be changed by client.
/// After call to deleteCompiledModule compiled functions from module become invalid.
std::unordered_map<std::string, void *> function_name_to_symbol;
};
/// Compile module. Client must fill module with necessary IR code.
CompiledModule compileModule(std::function<void (llvm::Module &)> compile_function);
/// Delete compiled module. Pointers to functions from module become invalid after this call.
void deleteCompiledModule(const CompiledModule & module_info);
/// Register external symbol for CHJIT instance to use, during linking.
void registerExternalSymbol(const std::string & symbol_name, void * address);
/// Total compiled code size for module that are currently valid.
inline size_t getCompiledCodeSize() const;
}
auto jit = DB::CHJIT();
auto compiled_sum_module = jit.compileModule([](llvm::Module & module)
{
llvm::LLVMContext & context = module.getContext();
llvm::IRBuilder<> b(context);
llvm::Type * int64_type = b.getInt64Ty();
std::vector params = {int64_type, int64_type};
bool is_var_args = false;
llvm::FunctionType * func_type = llvm::FunctionType::get(int64_type, params, is_var_args);
llvm::Function::LinkageTypes linkage = llvm::Function::ExternalLinkage;
llvm::Function * function = llvm::Function::Create(func_type, linkage, "sum", module);
llvm::Value * first_argument = function->args().begin(); /// Get first argument
llvm::Value * second_argument = function->args().begin() + 1; /// Get second argument
llvm::BasicBlock * entry = llvm::BasicBlock::Create(context, "entry", function);
b.SetInsertPoint(entry);
llvm::Value * sum = b.CreateAdd(first_argument, second_argument); /// Sum arguments
b.CreateRet(sum); /// Return sum result
});
using SumFunc = int64_t (*)(int64_t, int64_t);
auto sum_func = reinterpret_cast(compiled_sum_module.function_name_to_symbol["sum"]);
printf("Sum %ld\n", sum_func(1, 2));
jit.deleteCompiledModule(compiled_sum_module);
llvm::Function * function = llvm::Function::Create(func_type, linkage, "sum", module);
llvm::Value * first_argument = function->args().begin(); /// Get first argument
llvm::Value * second_argument = function->args().begin() + 1; /// Get second argument
llvm::BasicBlock * entry = llvm::BasicBlock::Create(context, "entry", function);
b.SetInsertPoint(entry);
llvm::Value * sum = b.CreateAdd(first_argument, second_argument); /// Sum arguments
b.CreateRet(sum); /// Return sum result
IR:
define i64 @sum(i64 %0, i64 %1) {
entry:
%2 = add i64 %0, %1
ret i64 %2
}
Assembler:
.text
.file "jit0"
.globl sum # -- Begin function sum
.p2align 4, 0x90
.type sum,@function
sum: # @sum
# %bb.0: # %entry
leaq (%rdi,%rsi), %rax
retq
.Lfunc_end0:
.size sum, .Lfunc_end0-sum # -- End function
For each function pages must be allocated using mmap, or malloc with page alignment and mprotect. In kernel each mapping is stored as separate vma (virtual memory area).
Process maximum vma count is controlled by setting max_map_count. During mprotect with different areas permissions, area is splitted in 2 areas using split_vma.
Areas can also be merged if they are located side by side, using mprotect_fixup.
| R + W | | R + E | => | R + W | | R + W | => | R + W |
Because of split_vma, default max_map_count can be easily exceeded.
Non trivial allocator + maximum cache size is required to support W^X (write xor execute) policy. Because we must write data in area with READ + WRITE permissions, then use mprotect with READ + EXEC permissions, that will lead to vma_split.
Numeric columns - PODArray. Almost same as std::vector.
1. Use our Allocator with support of realloc.
2. No additional memset during resize.
3. Padding with 15 bytes at the end.
Nullable columns contain data column and UInt8 column bitmask is element null.
Const column is column with 1 constant value.
Non numeric columns does not support JIT compilation.
ClickHouse uses vectorized execution model. Data is processing in blocks. Block contain multiple columns with maxium 65536 rows. Each column is stored as a vector of primitive data types or their combination.
1. Better utilization for CPU caches and pipeline.
2. Data is processed using SIMD instructions.
EXPLAIN PIPELINE SELECT a + b + c FROM test_table
┌─explain───────────────────┐
│ (Expression) │
│ ExpressionTransform │
│ (SettingQuotaAndLimits) │
│ (ReadFromStorage) │
│ TinyLog 0 → 1 │
└───────────────────────────┘
Expressions are represented in DAG that has input, function, constant nodes.
SELECT a + b + c FROM test_table;
Takes arguments as columns and returns function result as column.
class IFunction
{
virtual ~IFunction() = default;
virtual ColumnPtr executeImpl(
const ColumnsWithTypeAndName & arguments,
const DataTypePtr & result_type,
size_t input_rows_count) const = 0;
...
}
Specializations using templates for different types. Example sum, multiply for different types combinations.
Specializations for constant columns. Example sum, multiply with constant column.
1. During DAG interpretation, data is moving between functions. Operations are not fused.
Example plus(plus(a, b), c)) first plus on columns a and b is performed and result stored in temporary column. Then plus on result of previous plus and column c is performed.
2. Code bloat for different function specializations using templates, increase binary size.
3. For AVX256, AVX512 instructions need to use runtime instructions specialization using CPUID. Necessary for distributing portable binary.
SELECT a + b + c FROM test_table;
SET compile_expressions = 1;
SELECT a + b + c FROM test_table;
1. Improve L1, L2 cache usages.
2. Less code to execute. It is placed on 1 page. Better usage of CPU branch predictor.
3. Eliminate indirections.
4. Multiple operations are fused in one function. More optimizations can be performed by compiler.
5. Using target CPU intructions.
Latency Comparison Numbers ---------------------------------- L1 cache reference 0.5 ns Branch mispredict 5 ns L2 cache reference 7 ns 14x L1 cache Mutex lock/unlock 25 ns Main memory reference 100 ns 20x L2 cache, 200x L1 cache Compress 1K bytes with Zippy 3,000 ns 3 us Send 1K bytes over 1 Gbps network 10,000 ns 10 us Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD Read 1 MB sequentially from memory 250,000 ns 250 us Round trip within same datacenter 500,000 ns 500 us
class IFunction
{
...
virtual ~IFunction() = default;
bool isCompilable(const DataTypes & arguments) const;
llvm::Value * compile(
llvm::IRBuilderBase &,
const DataTypes & arguments,
Values values) const;
...
}
template <typename A, typename B>
class FunctionPlusImpl
{
static llvm::Value * compile(
llvm::IRBuilder<> & b,
llvm::Value * left,
llvm::Value * right,
bool is_signed)
{
return left->getType()->isIntegerTy() ? b.CreateAdd(left, right) : b.CreateFAdd(left, right);
}
}
template <typename A, typename B>
class FunctionMultiplyImpl
{
static llvm::Value * compile(
llvm::IRBuilder<> & b,
llvm::Value * left,
llvm::Value * right,
bool is_signed)
{
return left->getType()->isIntegerTy() ? b.CreateMul(left, right) : b.CreateFMul(left, right);
}
}
llvm::Value * compileImpl(
llvm::IRBuilderBase & builder,
const DataTypes & types,
std::vector<llvm::Value *> values) const override
{
auto & b = static_cast<llvm::IRBuilder<>>(builder);
auto return_type = getReturnTypeImpl(types);
auto * head = b.GetInsertBlock();
auto * context = head->getContext();
auto * join = llvm::BasicBlock::Create(context, "join_block", head->getParent());
std::vector<std::pair<llvm::BasicBlock *, llvm::Value *>> returns;
for (size_t i = 0; i + 1 < types.size(); i += 2)
{
auto index = std::to_string(i);
auto * then = llvm::BasicBlock::Create(context, "then_" + index, head->getParent());
auto * next = llvm::BasicBlock::Create(context, "next_" + index, head->getParent());
b.CreateCondBr(nativeBoolCast(b, types[i], values[i]), then, next);
b.SetInsertPoint(then);
auto * value = nativeCast(b, types[i + 1], values[i + 1], return_type);
returns.emplace_back(b.GetInsertBlock(), value);
b.CreateBr(join);
b.SetInsertPoint(next);
}
returns.emplace_back(b.GetInsertBlock(), nativeCast(b, types.back(), values.back(), return_type));
b.CreateBr(join);
b.SetInsertPoint(join);
auto * phi = b.CreatePHI(toNativeType(b, return_type), returns.size());
for (const auto & [block, value] : returns)
phi->addIncoming(value, block);
return phi;
}
1. For each node in DAG get children_size, compilable_children_size
2. Sort nodes in descending order of compilable_children_size, to first compile nodes with most children.
3. Check if node can be compiled using heuristics currently we require node to contain at least 1 compilable children, and do not compile its children.
4. Compile node functions together into function that takes raw columns data pointers and return expression result.
4. Replace node in DAG with special LLVMFunction node. LLVMFunction execute method converts columns into raw data and call compiled function.
1. Binary operators. Example plus, minus, multiply, xor.
2. Unary operators. Example abs.
3. Logical functions. Example and, or, not.
4. Branch functions. Example if, multiIf.
5. Bit shift functions. Example bitShiftLeft
SELECT a + b * c + 5 FROM test_jit_merge_tree;
loop: ; preds = %loop, %entry
%19 = phi i64 [ 0, %entry ], [ %34, %loop ] /// Get counter phi node. If started from entry it is 0.
%20 = phi i64* [ %5, %entry ], [ %30, %loop ] /// Argument column phi node
%21 = phi i64* [ %9, %entry ], [ %31, %loop ] /// Argument column phi node
%22 = phi i64* [ %13, %entry ], [ %32, %loop ] /// Argument column phi node
%23 = phi i64* [ %17, %entry ], [ %33, %loop ] /// Result column phi node
%24 = load i64, i64* %20, align 8 /// Load argument current row
%25 = load i64, i64* %21, align 8 /// Load argument current row
%26 = load i64, i64* %22, align 8 /// Load argument current row
%27 = mul i64 %25, %26 /// Multiply b * c
%28 = add i64 %24, %27 /// Add a + result of multiply b * c
%29 = add i64 %28, 5 /// Add with constant 5
store i64 %29, i64* %23, align 8 /// Store value in result column
%30 = getelementptr inbounds i64, i64* %20, i64 1 /// Adjust pointer to next element
%31 = getelementptr inbounds i64, i64* %21, i64 1 /// Adjust pointer to next element
%32 = getelementptr inbounds i64, i64* %22, i64 1 /// Adjust pointer to next element
%33 = getelementptr inbounds i64, i64* %23, i64 1 /// Adjust pointer to next element
%34 = add i64 %19, 1 /// Increase counter
%35 = icmp eq i64 %34, %0br i1 %35, label %end, label %loop /// Check loop predicate
void aPlusBMulitplyCPlusConstant(
int64_t * a,
int64_t * b,
int64_t * c,
int64_t constant,
int64_t * result,
size_t size)
{
for (size_t i = 0; i < size; ++i)
{
*result = (*a) + (*b) * (*c) + constant;
++a;
++b;
++c;
++result;
}
}
.LBB0_8: # %vector.body
vmovdqu (%r11,%rax,8), %ymm1
vmovdqu (%r9,%rax,8), %ymm3
vmovdqu 32(%r11,%rax,8), %ymm2
vmovdqu 32(%r9,%rax,8), %ymm4
vpsrlq $32, %ymm3, %ymm5
vpsrlq $32, %ymm1, %ymm6
vpmuludq %ymm1, %ymm5, %ymm5
vpmuludq %ymm6, %ymm3, %ymm6
vpmuludq %ymm1, %ymm3, %ymm1
vpsrlq $32, %ymm4, %ymm3
vpmuludq %ymm2, %ymm3, %ymm3
vpaddq %ymm5, %ymm6, %ymm5
vpsllq $32, %ymm5, %ymm5
vpaddq %ymm5, %ymm1, %ymm1
vpsrlq $32, %ymm2, %ymm5
vpmuludq %ymm2, %ymm4, %ymm2
vpaddq (%r14,%rax,8), %ymm1, %ymm1
vpmuludq %ymm5, %ymm4, %ymm5
vpaddq %ymm3, %ymm5, %ymm3
vpsllq $32, %ymm3, %ymm3
vpaddq %ymm3, %ymm2, %ymm2
vpaddq 32(%r14,%rax,8), %ymm2, %ymm2
vpaddq %ymm0, %ymm1, %ymm1 /// in ymm0 there is constant 5. vpbroadcastq (%rbp), %ymm0
vmovdqu %ymm1, (%r10,%rax,8)
vpaddq %ymm0, %ymm2, %ymm2
vmovdqu %ymm2, 32(%r10,%rax,8)
addq $8, %rax
cmpq %rax, %r8
JIT standard expression compilation time is around 15 ms. Grows linearly with code size.
Typical compiled expression use 1 page for code section and 1 page for data section. 4096 * 2 = 8192 bytes on most configurations.
Introspection works inside ClickHouse using `CompileExpressionsMicroseconds`, `CompileExpressionsBytes` metrics.
SELECT
ProfileEvents['CompileExpressionsMicroseconds'] AS compiled_time,
ProfileEvents['CompileExpressionsBytes'] AS compiled_bytes
FROM system.query_log
WHERE compiled_time > 0;
┌─compiled_time─┬─compiled_bytes─┐
│ 16258 │ 8192 │
│ 26792 │ 8192 │
│ 15280 │ 8192 │
│ 11594 │ 8192 │
│ 14989 │ 8192 │
└───────────────┴────────────────┘
SELECT count() FROM hits
WHERE
((EventDate >= '2018-08-01')
AND (EventDate <= '2018-08-03')
AND (CounterID >= 34))
OR ((EventDate >= '2018-08-04')
AND (EventDate <= '2018-08-05')
AND (CounterID <= 101500))
— 649 533 033 rows per second.
SET compile_expressions = 1;
SELECT count() FROM hits
WHERE
((EventDate >= '2018-08-01')
AND (EventDate <= '2018-08-03')
AND (CounterID >= 34))
OR ((EventDate >= '2018-08-04')
AND (EventDate <= '2018-08-05')
AND (CounterID <= 101500))
— 865 491 052 rows per second.
— +33% performance improvement!
SELECT
number * 2 +
number * 3 +
number * 4 +
number * 5
FROM system.numbers
FORMAT Null
— 0 rows in set. Elapsed: 0.903 sec. Processed 329.23 million rows, 2.63 GB (364.78 million rows/s., 2.92 GB/s.
SET compile_expressions = 1;
SELECT
number * 2 +
number * 3 +
number * 4 +
number * 5
FROM system.numbers
FORMAT Null
— 0 rows in set. Elapsed: 1.602 sec. Processed 1.89 billion rows, 15.15 GB (1.18 billion rows/s., 9.46 GB/s.)
—
+323% performance improvement!
SET compile_expressions = 1;
WITH number AS x, if(x = 1, 1, if(x = 2, 2,
if(x = 3, 3, if(x = 4, 4, if(x = 5, 5,
if(x = 6, 6, if(x = 7, 7, if(x = 8, 8,
if(x = 9, 9, if(x = 10, 10,
if(x = 11, 11, 12))))))))))) AS res
SELECT sum(res)
FROM numbers(10000000)
— 0 rows in set. Elapsed: 0.150 sec. Processed 10.02 million rows, 80.18 MB (66.95 million rows/s., 535.56 MB/s.).
SET compile_expressions = 1;
WITH number AS x, if(x = 1, 1, if(x = 2, 2,
if(x = 3, 3, if(x = 4, 4, if(x = 5, 5,
if(x = 6, 6, if(x = 7, 7, if(x = 8, 8,
if(x = 9, 9, if(x = 10, 10,
if(x = 11, 11, 12))))))))))) AS res
SELECT sum(res)
FROM numbers(10000000)
— 0 rows in set. Elapsed: 0.061 sec. Processed 10.02 million rows, 80.18 MB (163.20 million rows/s., 1.31 GB/s.)
—
+244% performance improvement!
EXPLAIN SELECT sum(UserID)
FROM default.hits_100m_obfuscated GROUP BY WatchID
┌─explain──────────────────────────────────────┐
│ Expression ((Projection + Before ORDER BY)) │
│ Aggregating │
│ Expression (Before GROUP BY) │
│ SettingQuotaAndLimits │
│ ReadFromMergeTree │
└──────────────────────────────────────────────┘
class IAggregateFunction
{
...
virtual ~IAggregateFunction() = default;
/// AggregateDataPtr pointer to aggregate data for unique key during GROUP BY
/// Create empty data for aggregation with `placement new` at the specified location.
virtual void create(AggregateDataPtr place) const = 0;
/** Adds a value into aggregation data on which place points to.
* columns points to columns containing arguments of aggregation function.
* row_num is number of row which should be added.
*/
virtual void add(
AggregateDataPtr place,
const IColumn ** columns,
size_t row_num,
Arena * arena) const = 0;
/// Merges state (on which place points to) with other state of current aggregation function.
virtual void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const = 0;
/// Inserts results into a column. This method might modify the state (e.g.
/// sort an array), so must be called once, from single thread.
virtual void insertResultInto(AggregateDataPtr place, IColumn & to, Arena * arena) const = 0;
...
}
SELECT
sum(UserID),
sum(ClientIP),
sum(CounterClass),
sum(CounterID),
sum(WatchID)
FROM default.hits_100m_obfuscated
GROUP BY WatchID
1. For each unique key create aggregate data for each function.
2. For each key add value for aggregate data for each function.
3. For each unique key merge aggregate data for each function, in case multiple threads are used.
4. For each unique key insert result into final columns for each function.
1. A lot of virtual function calls.
2. For Nullable columns we have Nullable wrapper, additional indirection layer.
3. Aggregation combinators. -If, -Array, additional indirection layer.
Fuse multiple aggregate functions actions into one.
Functions require 4 actions create, add, merge, insert. Fuse them and compile into 4 functions.
1. Create function for multiple aggregate functions.
2. Add function for multiple aggregate functions.
3. Merge function for mutiple aggregate function.
4. Insert final result function for multiple aggregate functions.
1. Most common aggregate functions sum, count, min, max, avg, avgWeighted.
2. Combinators -If.
3. Nullable aggregate function adaptor.
SELECT
sum(UserID),
avg(ClientIP),
sum(CounterClass),
min(CounterID),
max(WatchID)
FROM default.hits_100m_obfuscated
GROUP BY WatchID
SELECT
sum_avg_sum_min_max(
UserID,
ClientIP,
CounterClass,
CounterID,
WatchID)
FROM default.hits_100m_obfuscated
GROUP BY WatchID
SELECT
sum(UserID),
sum(ClientIP),
sum(CounterClass),
sum(CounterID),
sum(WatchID)
FROM default.hits_100m_obfuscated
GROUP BY WatchID
— 0 rows in set. Elapsed: 5.504 sec. Processed 100.00 million rows, 2.50 GB (18.17 million rows/s., 454.21 MB/s.)
SET compile_aggregate_expression = 1;
SELECT
sum(UserID),
sum(ClientIP),
sum(CounterClass),
sum(CounterID),
sum(WatchID)
FROM default.hits_100m_obfuscated
GROUP BY WatchID
— 0 rows in set. Elapsed: 4.146 sec. Processed 100.00 million rows, 2.50 GB (24.12 million rows/s., 603.06 MB/s.)
— +34% performance improvement!
WITH (WatchID % 2 == 0) AS predicate
SELECT
minIf(UserID, predicate),
minIf(ClientIP, predicate),
minIf(CounterClass, predicate),
minIf(CounterID, predicate),
minIf(WatchID, predicate)
FROM default.hits_100m_obfuscated
GROUP BY WatchID
— 0 rows in set. Elapsed: 6.234 sec. Processed 100.00 million rows, 2.50 GB (16.04 million rows/s., 401.05 MB/s.)
SET compile_aggregate_expression = 1;
WITH (WatchID % 2 == 0) AS predicate
SELECT
minIf(UserID, predicate),
minIf(ClientIP, predicate),
minIf(CounterClass, predicate),
minIf(CounterID, predicate),
minIf(WatchID, predicate)
FROM default.hits_100m_obfuscated
GROUP BY WatchID
— 0 rows in set. Elapsed: 4.146 sec. Processed 100.00 million rows, 2.50 GB (24.12 million rows/s., 603.06 MB/s.)
— +71% performance improvement!
JIT compilation improves performance of expression evaluation and aggregation.
For expression evaluation improve performance in 1.5-3 times (for some cases more than 20 times).
For aggregation improve performance in 1.15-2 times.


| |subject| |
| What to do| |
|time| |
|Date| |
|Location| |
- Submit assignment|Others|22-12-2019 | 5:00pm | douglas
- collect my PVC|Make a call|12-12-2019 | 1:50pm | Owerri
- Purchase champions league ticket|Others|12-10-2019 | 3:50pm | Obinze
- Register for green foundation |send Mail|31-04-2019| 7:00am | my phone


Match files using the patterns the shell uses, like stars and stuff.
This is a glob implementation in JavaScript. It uses the minimatch
library to do its matching.
var glob = require("glob")
// options is optional
glob("**/*.js", options, function (er, files) {
// files is an array of filenames.
// If the `nonull` option is set, and nothing
// was found, then files is ["**/*.js"]
// er is an error object or null.
})
"Globs" are the patterns you type when you do stuff like ls *.js
on
the command line, or put build/*
in a .gitignore
file.
Before parsing the path part patterns, braced sections are expanded
into a set. Braced sections start with {
and end with }
, with any
number of comma-delimited sections within. Braced sections may contain
slash characters, so a{/b/c,bcd}
would expand into a/b/c
and abcd
.
The following characters have special magic meaning when used in a path portion:
*
Matches 0 or more characters in a single path portion?
Matches 1 character[...]
Matches a range of characters, similar to a RegExp range.
If the first character of the range is !
or ^
then it matches
any character not in the range.!(pattern|pattern|pattern)
Matches anything that does not match
any of the patterns provided.?(pattern|pattern|pattern)
Matches zero or one occurrence of the
patterns provided.+(pattern|pattern|pattern)
Matches one or more occurrences of the
patterns provided.*(a|b|c)
Matches zero or more occurrences of the patterns provided@(pattern|pat*|pat?erN)
Matches exactly one of the patterns
provided**
If a "globstar" is alone in a path portion, then it matches
zero or more directories and subdirectories searching for matches.
It does not crawl symlinked directories.If a file or directory path portion has a .
as the first character,
then it will not match any glob pattern unless that pattern's
corresponding path part also has a .
as its first character.
For example, the pattern a/.*/c
would match the file at a/.b/c
.
However the pattern a/*/c
would not, because *
does not start with
a dot character.
You can make glob treat dots as normal characters by setting
dot:true
in the options.
If you set matchBase:true
in the options, and the pattern has no
slashes in it, then it will seek for any file anywhere in the tree
with a matching basename. For example, *.js
would match
test/simple/basic.js
.
If no matching files are found, then an empty array is returned. This differs from the shell, where the pattern itself is returned. For example:
$ echo a*s*d*f
a*s*d*f
To get the bash-style behavior, set the nonull:true
in the options.
man sh
man bash
(Search for "Pattern Matching")man 3 fnmatch
man 5 gitignore
Returns true
if there are any special characters in the pattern, and
false
otherwise.
Note that the options affect the results. If noext:true
is set in
the options object, then +(a|b)
will not be considered a magic
pattern. If the pattern has a brace expansion, like a/{b/c,x/y}
then that is considered magical, unless nobrace:true
is set in the
options.
pattern
{String}
Pattern to be matchedoptions
{Object}
cb
{Function}
err
{Error | null}
matches
{Array<String>}
filenames found matching the patternPerform an asynchronous glob search.
pattern
{String}
Pattern to be matchedoptions
{Object}
{Array<String>}
filenames found matching the patternPerform a synchronous glob search.
Create a Glob object by instantiating the glob.Glob
class.
var Glob = require("glob").Glob
var mg = new Glob(pattern, options, cb)
It's an EventEmitter, and starts walking the filesystem to find matches immediately.
pattern
{String}
pattern to search foroptions
{Object}
cb
{Function}
Called when an error occurs, or matches are founderr
{Error | null}
matches
{Array<String>}
filenames found matching the patternNote that if the sync
flag is set in the options, then matches will
be immediately available on the g.found
member.
minimatch
The minimatch object that the glob uses.options
The options object passed in.aborted
Boolean which is set to true when calling abort()
. There
is no way at this time to continue a glob search after aborting, but
you can re-use the statCache to avoid having to duplicate syscalls.cache
Convenience object. Each field has the following possible
values:false
- Path does not existtrue
- Path exists'FILE'
- Path exists, and is not a directory'DIR'
- Path exists, and is a directory[file, entries, ...]
- Path exists, is a directory, and the
array value is the results of fs.readdir
statCache
Cache of fs.stat
results, to prevent statting the same
path multiple times.symlinks
A record of which paths are symbolic links, which is
relevant in resolving **
patterns.realpathCache
An optional object which is passed to fs.realpath
to minimize unnecessary syscalls. It is stored on the instantiated
Glob object, and may be re-used.end
When the matching is finished, this is emitted with all the
matches found. If the nonull
option is set, and no match was found,
then the matches
list contains the original pattern. The matches
are sorted, unless the nosort
flag is set.match
Every time a match is found, this is emitted with the specific
thing that matched. It is not deduplicated or resolved to a realpath.error
Emitted when an unexpected error is encountered, or whenever
any fs error occurs if options.strict
is set.abort
When abort()
is called, this event is raised.pause
Temporarily stop the searchresume
Resume the searchabort
Stop the search foreverAll the options that can be passed to Minimatch can also be passed to Glob to change pattern matching behavior. Also, some have been added, or have glob-specific ramifications.
All options are false by default, unless otherwise noted.
All options are added to the Glob object, as well.
If you are running many glob
operations, you can pass a Glob object
as the options
argument to a subsequent operation to shortcut some
stat
and readdir
calls. At the very least, you may pass in shared
symlinks
, statCache
, realpathCache
, and cache
options, so that
parallel glob operations will be sped up by sharing information about
the filesystem.
cwd
The current working directory in which to search. Defaults
to process.cwd()
.root
The place where patterns starting with /
will be mounted
onto. Defaults to path.resolve(options.cwd, "/")
(/
on Unix
systems, and C:\
or some such on Windows.)dot
Include .dot
files in normal matches and globstar
matches.
Note that an explicit dot in a portion of the pattern will always
match dot files.nomount
By default, a pattern starting with a forward-slash will be
"mounted" onto the root setting, so that a valid filesystem path is
returned. Set this flag to disable that behavior.mark
Add a /
character to directory matches. Note that this
requires additional stat calls.nosort
Don't sort the results.stat
Set to true to stat all results. This reduces performance
somewhat, and is completely unnecessary, unless readdir
is presumed
to be an untrustworthy indicator of file existence.silent
When an unusual error is encountered when attempting to
read a directory, a warning will be printed to stderr. Set the
silent
option to true to suppress these warnings.strict
When an unusual error is encountered when attempting to
read a directory, the process will just continue on in search of
other matches. Set the strict
option to raise an error in these
cases.cache
See cache
property above. Pass in a previously generated
cache object to save some fs calls.statCache
A cache of results of filesystem information, to prevent
unnecessary stat calls. While it should not normally be necessary
to set this, you may pass the statCache from one glob() call to the
options object of another, if you know that the filesystem will not
change between calls. (See "Race Conditions" below.)symlinks
A cache of known symbolic links. You may pass in a
previously generated symlinks
object to save lstat
calls when
resolving **
matches.sync
DEPRECATED: use glob.sync(pattern, opts)
instead.nounique
In some cases, brace-expanded patterns can result in the
same file showing up multiple times in the result set. By default,
this implementation prevents duplicates in the result set. Set this
flag to disable that behavior.nonull
Set to never return an empty set, instead returning a set
containing the pattern itself. This is the default in glob(3).debug
Set to enable debug logging in minimatch and glob.nobrace
Do not expand {a,b}
and {1..3}
brace sets.noglobstar
Do not match **
against multiple filenames. (Ie,
treat it as a normal *
instead.)noext
Do not match +(a|b)
"extglob" patterns.nocase
Perform a case-insensitive match. Note: on
case-insensitive filesystems, non-magic patterns will match by
default, since stat
and readdir
will not raise errors.matchBase
Perform a basename-only match if the pattern does not
contain any slash characters. That is, *.js
would be treated as
equivalent to **/*.js
, matching all js files in all directories.nodir
Do not match directories, only files. (Note: to match
only directories, simply put a /
at the end of the pattern.)ignore
Add a pattern or an array of glob patterns to exclude matches.
Note: ignore
patterns are always in dot:true
mode, regardless
of any other settings.follow
Follow symlinked directories when expanding **
patterns.
Note that this can result in a lot of duplicate references in the
presence of cyclic links.realpath
Set to true to call fs.realpath
on all of the results.
In the case of a symlink that cannot be resolved, the full absolute
path to the matched entry is returned (though it will usually be a
broken symlink)While strict compliance with the existing standards is a worthwhile goal, some discrepancies exist between node-glob and other implementations, and are intentional.
The double-star character **
is supported by default, unless the
noglobstar
flag is set. This is supported in the manner of bsdglob
and bash 4.3, where **
only has special significance if it is the only
thing in a path part. That is, a/**/b
will match a/x/y/b
, but
a/**b
will not.
Note that symlinked directories are not crawled as part of a **
,
though their contents may match against subsequent portions of the
pattern. This prevents infinite loops and duplicates and the like.
If an escaped pattern has no matches, and the nonull
flag is set,
then glob returns the pattern as-provided, rather than
interpreting the character escapes. For example,
glob.match([], "\\*a\\?")
will return "\\*a\\?"
rather than
"*a?"
. This is akin to setting the nullglob
option in bash, except
that it does not resolve escaped pattern characters.
If brace expansion is not disabled, then it is performed before any
other interpretation of the glob pattern. Thus, a pattern like
+(a|{b),c)}
, which would not be valid in bash or zsh, is expanded
first into the set of +(a|b)
and +(a|c)
, and those patterns are
checked for validity. Since those two are valid, matching proceeds.
Previously, this module let you mark a pattern as a "comment" if it
started with a #
character, or a "negated" pattern if it started
with a !
character.
These options were deprecated in version 5, and removed in version 6.
To specify things that should not match, use the ignore
option.
Please only use forward-slashes in glob expressions.
Though windows uses either /
or \
as its path separator, only /
characters are used by this glob implementation. You must use
forward-slashes only in glob expressions. Back-slashes will always
be interpreted as escape characters, not path separators.
Results from absolute patterns such as /foo/*
are mounted onto the
root setting using path.join
. On windows, this will by default result
in /foo/*
matching C:\foo\bar.txt
.
Glob searching, by its very nature, is susceptible to race conditions, since it relies on directory walking and such.
As a result, it is possible that a file that exists when glob looks for it may have been deleted or modified by the time it returns the result.
As part of its internal implementation, this program caches all stat and readdir calls that it makes, in order to cut down on system overhead. However, this also makes it even more susceptible to races, especially if the cache or statCache objects are reused between glob calls.
Users are thus advised not to use a glob result as a guarantee of filesystem state in the face of rapid changes. For the vast majority of operations, this is never a problem.
Any change to behavior (including bugfixes) must come with a test.
Patches that fail tests or reduce performance will be rejected.
# to run tests
npm test
# to re-generate test fixtures
npm run test-regen
# to benchmark against bash/zsh
npm run bench
# to profile javascript
npm run prof


{{data.first_name}}, you are registered for the DESC October 2021 Sprint Week!
Sprinters aiming to attend in person will receive an email as soon as possible from their intended hub to confirm participation and provide additional site-specific information. Whether in-person or remote, we are looking forward to sprinting together!
The
Participants tab on the confluence page links to a live list of those who have expressed interest in this Sprint Week.
And have a look at the
Sprints page to propose and join a sprint!
Your Logistics Organizing Committee (LOC)


Adding Sample
Add Sample
0
examples
Adding Sample
Add Sample
0
examples
TRAIN MODEL
PLAY
Learning rate
0.00001
0.0001
0.001
0.003
Batch size
0.05
0.1
0.4
1
Epochs
10
20
40
Hidden units
10
100
200
Model Select
Load
Minimum Face Size:
-
+
Entropy Threshold:
-
+
Minimum Unit:
-
+
Time:
Estimated Fps:
Left:
Right:
Down:
Entropy:


|
JQ6500 MP3 Player Arduino Library
A simple library to control a JQ6500 MP3 Player Module from an Arduino.
|
Simple to use Arduino library to interface to JQ6500 (JQ6500-28P, JQ6500-16P) Mp3 Player Modules
For complete documentation about the JQ6500 Mp3 Player Module, see: https://sparks.gogo.co.nz/jq6500/index.html
For a library methods reference see: https://sleemanj.github.io/JQ6500_Serial/html/index.html
For Linux Upload and Windows Upload Repair Tool (JQ6500-16) see: https://github.com/NikolaiRadke/JQ6500-rescue-tool
There are two varients of the JQ6500 module as shown.
To use this library with a 5v Arduino, connect as follows.
| JQ6500 Module | Arduino |
|---|---|
| RX | through a 1K Resistor then to pin 9 |
| TX | pin 8 |
| GND (any of) | GND |
| VCC (any of) | VCC |
To use this library with a 3v3 Arduino, connect as follows...
| JQ6500 Module | Arduino |
|---|---|
| RX | pin 9 |
| TX | pin 8 |
| GND (any of) | GND |
| VCC (any of) | VCC |
You can use pins other than 9 and 8 if you wish, simply set them in your code.
If using the on-board speaker driver, then naturally the power demands are significant, and your USB power may not be sufficient at more 1/3rd level of volume or so, the symptom is the audo breaking up and potentially resetting when volume increases.
You should use either an external power source, an external amp, or a lower volume if you experience this problem.
JQ6500 instance and serial connection
Define a new instance of JQ6500_Serial, passing the serial connection the module is connected to.
You can use any Serial libraries that implement a Stream object, for example:
Hardware serial connection (see PlayByNumber example):
JQ6500_Serial mp3(Serial); [...] Serial.begin(9600);
Software serial connection (see other examples):
#include <SoftwareSerial.h> SoftwareSerial mySerial(RX_PIN, TX_PIN); JQ6500_Serial mp3(mySerial); [...] mySerial.begin(9600);


Nested Logit Models
In order to quantify the impact of the Manhattan Congestion Pricing policy, we have compared the simulated ridership under the new pricing scenario against the simulated baseline scenario. For that purpose, we have first used the LEHD/LODES as a proxy for urban mobility, then trained a nested multimonial logit model based on choices reported in ACS and actual proportions of taxi, FHV and shared FHV observed in the data, and finally compared the simulated ridership to the prior observed preferences to assess the predicted modal shifts under different scenaris.
Choose the best parameters
Tune the parameters by comparing the model results with
ground choice. We use monte carlo in choosing parameters. Regrading sampling taxi zones,
we first try to randomly choose 10 taxi zones； then try to pick the taxi zones which
cover 60% population. Apply grid search to those sampling taxi zones. The loss function
that we tried include root of mean saqure error (RMSE), normalized RMSE, weighting cummulative loss,
and RMSE based on total population for each mode. Finally pick the best parameters from 48 combination
of Tao and Lambda. We also apply uncertatinty in our results.
The below table shows the relative values of standard deviation for each mode
and scenario relative to the mean value so that we can get a better idea of what
sort of variation to expect from the model results.
Quantitatively evaluate THE impacts of Manhattan Congestion Pricing Policy basen on our transportation mode shift model of three scenarios:
This table shows a distribution view of the scaled results of our model simulations.
Numbers represent the proportion of total NYC commute trips for each mode predicted under
each scenario. Specifically, an overall 0.16% drop (about 4,700 trips) in Taxi and (non-shared)
FHV trips during the daily morning commute hours under the $2.75 tax, and an overall 0.08% drop
(about 23,000 trips) under the $10 tax. The private vehicle trips decrease 0.17% (about 4,800 trips)
under the $2.75 tax and 2.73% (about 80,000 trips) under $10 tax. In contrast, shared FHV trips,
Public Transportation trips, and Walking trips increase in both scenarios.
Based on the means and the standard deviations of our models,
the uncertainties of the proportions are as follows: Taxi±0.05%, FHV±0.14%, Shared FHV±0.19%,
Public Transportation±0.23%, Walking±0.05%, Private Vehicles±0.14%.
The distribution of the revenues for the four transportation modes under different
price scenarios, along with the actual amount change displayed in the table.This
bar chart on the left shows the change in revenues for Public Transportation
(MTA), Taxi, FHV, and Shared-FHV under each price scenario. Corresponding to the
mode shift, there are predicted a reduction in Taxi and (non-shared) FHV revenues
under both Congestion Pricing Scenarios, and an increase in Shared- FHV and MTA revenues.
The table on the right displays the actual amount of change in dollars between scenarios
with the corresponding percentage. Taxi revenue has the biggest percentage drop (about 40%)
each time, and MTA has the greatest growth in number (about $72,000 and $551,000).
Non-shared FHV has a slight decrease in revenues under each price scenario, however,
the increase in shared FHV (about 50% each time) can easily cover that loses and creates
extra profits for the total FHV revenue (the overall FHV revenue increases $15,952 from
status quo to $2.75 tax and $39,495 from $2.75 to $10 tax).
The Tax Revenue from the Congestion Surcharge under each scenario. The predicted
tax revenue is compared with a "zero scenario" revenue —— the expected revenue
if the surcharge were imposed and no commuters change their mode choice behaviors.
The results show that both of the predicted revenues after the mode shift in
scenario 2 and 3 are about 50% lower than the zero scenario revenues.
This indicates the advantage of our methodology, as the use of a mode shift model
provides a more realistic prediction of future revenues, as it accounts for behavior
changes resulting from the tax. Policy makers using the zero scenario might vastly
over-estimate surcharge tax revenues.The uncertainties of the predicted revenues are ± $5,000
under $2.75 Tax scenario and ± $22,000 in $10 Tax scenario.
Origin taxi zones on the left are shaded by the predicted percent decrease in total
taxi and FHV ridership under the $2.75 Congestion Tax scenario. Origin taxi
zones on the right are shaded by the predicted percent decrease in total taxi,
FHV, and private vehicle ridership under the $10 Congestion Tax scenario. Manhattan
taxi zones in or adjacent to the congestion zone are predicted to experience the
largest shift. All of the 37 origin taxi zones that the model predicts will experience
the most mode shift under the $10 Congestion Tax (predicted change is more than 28.57%,
which is one standard deviation above the mean predicted change) are in Manhattan. The
geographic range of impact is much larger in Scenario 3 ($10 surcharge).
Our model did not assume any exemptions for residents of the congestion zones,
and our results suggest that decisions around those exemptions may significantly
affect the impacts of the policy.
This table shows the subway ridership and the impact on average commute time and cost
under the 2 congestion surcharge scenarios. These are derived from the mean values of the
distribution created by running 5 sets of parameters with percentage variance.
We can see an increase in the ridership and commute time but, the cost remains somewhat similar.
This table shows the percentage changes in subway ridership average commute time and cost
under the 2 congestion surcharge scenarios. These are derived from the mean values of the
distribution created by running 5 sets of parameters with percentage variance as. We can see
a noticeable increase in the ridership and commute time but, the change
in the cost is relatively insignifican.
As seen in table 4 and table 5, the subway ridership and the commute time increased for
both the scenarios but, the change is more significant for the $10 Congestion Tax Scenario.
So, we can see that the average commuter will spend not only more time on their commute
but will also, most likely, have to commute in more crowded subway cars. Also, an interesting
impact seen here is that the commute cost increases slightly in the $2.75 congestion tax scenario
in contrast to it reducing in the $10 scenario. This is because the model predicted that most
of the taxi and FHV commuters simply switched to either shared FHVs or stuck to their mode of
choice and just paid the surcharge instead of shifting to the subway which dramatically cut
the cost which makes sense too as people are usually very reluctant to change their
transportation mode
.
The earlier cited work of Gibson, et. al provides a framework for us to quantitatively evaluate
the predicted environmental impacts of the surcharge scenarios. They found that for every daily
vehicle reduction emissions would be reduced by .00006552 microgram/meter cubed. They then
presented a framework for quantifying the economic benefit of this emissions reduction. They cite
1984 US government research that estimated that people were willing to pay $148.70 ($366.59 in 2019)
per year per person for every microgram/cubic meter reduction in pollution. If we assume that
every 60 miles (during the 6 am to 10 am morning commute window) in driving distance represents
one vehicle (conservatively assuming a constant 15 miles per hour), we can estimate the number
of vehicles reduced. From this framework we predict a very small reduction of 13 cars per commute
window under the $2.75 surcharge scenario and a reduction of 9,045 cars during the morning commute
under the $10 scenario. This includes total mileage reduction from taxis, FHVs and private
vehicles and accounts for the additional miles from the predicted increase in shared FHVs.
Under scenario 3 the framework presented by Gibson, et.al would predict a daily reduction of
approximately 0.6 micrograms/meters cubed for a 219 microgram/meters cubed yearly reduction of
harmful pollutants attributed to the morning commute hours. If we multiply that total by the
$366.59 per year a person is willing to pay for a reduction in unit of pollutants, we get a
yearly value of $80,348.91 per person impacted. Applied to the approximately 1.3 million
people living in Manhattan's congestion zone, the reductions environmental benefits are
significant. Notable from Gibson, et. al. was their finding that air quality benefits expanded
beyond the congestion zone, suggesting an even larger range of environmental benefit is possible.
The plot on the left shows total commuters by income that report using taxi, FHV, shared FHV
or private vehicles to commute to work. The plot on the right shows the expected net
reduction of Taxi, FHV, shared FHV and private vehicles predicted under Scenario 3 - $10
congestion surcharge - by income bracket. ACS income brackets are not evenly spaced, so
the numbers in each bracket were either summed or divided in order to create a perceptually
uniform plot, with each bar representing an income range of $25,000. In order to evaluate any
potential equity or accessibility concerns with the existing or
proposed congestion tax, the model's predicted mode shift segmented by wage
bracket are compared. Figure 3 plots the predicted net reduction (right) in vehicle commutes
from the baseline Scenario 1 to Scenario 3 - the proposed $10 surcharge - by income
bracket, as well as the total number of vehicle commuters in Scenario 1 (left). Many vehicle-based
commuters make fewer than $100,000 per year, suggesting potential for a congestion surcharge to
weigh heavily on the middle class. However, when plotting predicted mode shift as a result of the
surcharge, the surcharge appears to be a relative progressive tax, with the majority of the
mode shift experienced by people making over $75,000 per year.
The figure on the left shows the percent of taxi zone residents who work in the congestion
zone (shaded by home taxi zone). The figure on the right shows the percent of all taxi,
FHV, shared FHV and private vehicle commuters expected to shift modes due to the $10 surcharge.
Both figures reference the "Scenario 3" congestion surcharge of $10. The congestion zone
referenced is the corresponding zone, Manhattan below 60th st.. When comparing the two plots
in Figure 4, a higher percent of commuters working in the congestion zone is associated with
a higher percent of vehicle commuters predicted to change modes. This makes sense as commuters
not living or working in the congestion zone will not be affected by the surcharge during their
workday commutes. This dynamic may explain why we predict that commuters impacted by the surcharge will skew higher income.
The plot on the left shows the positive correlation between percent of commuters
working in the congestion zone and that home zone's median wage. The plot on the right shows
the negative correlation between the percent of commuters working in the congestion zone and
the percent of commuters choosing private vehicles for transportation to work. As shown in figure 5
The percent of people working in the congestions zone is associated with a higher median
income at the taxi zone level. Additionally, the percent of people working in the congestion
zone is associated with a lower percentage of people in that zone reporting private vehicles as
their transportation choice, suggesting that many private vehicle commuters may not work in
the congestion zone, and may not be impacted by the surcharge on their daily commutes.
To explore accessibility concerns, the map on the left is shaded according to the percent of residents in that zone age 65
or over, calculated as an average of all the census tracts in that zone. The map on the
right shows the percent of residents with a disability, calculated as the average of all
census tracts in that zone.
Figure 6 has been included to show the distribution of residents over the age of 65
or with a disability. While our model estimates mode choice based on a trade off between time
and cost, these populations may have additional concerns that might prevent them from switching
modes, particularly to public transportation, even if a surcharge made their vehicle-based
commute prohibitively expensive. While the final details of the proposed $10 surcharge are
not yet available, most news accounts report that there will be an exemption or discount for
populations with accessibility concerns, particularly for those living in the congestion zone.
Github: Manhattan-Congestion-Surcharge-Capstone
Paper: Impact of Manhattan Congestion Surcharge on For-Hire Vehicles
Project Mentor
Literature Review
& Report Writing Lead
Modeling and Analysis Lead
& Web Development
Modeling and Analysis Lead
Data Lead
Data Lead
BE THE BEST TEAM!


Rock Paper Scissors
$ ./rock-paper-scissors new_game
Hello from Rock Paper Scissors game. Please type your move.
>
Rock
Paper
Scissors


{#
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You 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.
#}
{% extends 'appbuilder/init.html' %}
{% import 'appbuilder/baselib.html' as baselib %}
{% block head_css %}
{{ super() }}
{% endblock %}
{% block body %}
{% include 'appbuilder/general/confirm.html' %}
{% include 'appbuilder/general/alert.html' %}
{% block navbar %}


This page cannot be found
We could not find the page you requested. This could be because the address was mistyped, or a link you followed was pointing at a page that no longer exists.
If you are here to view your mortgage then please start from the beginning
Please report any broken links by contacting us via email


Hello! My name is Jason Yu, and I am a Ph.D. student at the University of California, Irvine. I am also an NSF Graduate Research Fellow, part of a fellowship program sponsored by the National Science Foundation (More info can be found here: https://www.nsfgrfp.org/). My research interests involve the development and application of quantum chemistry methods, particularly those which involve Density Functional Theory (DFT) and Coupled Cluster (CC). To learn more about my research, including ongoing work, you can visit the “Research” section in the sidebar above.
I have a Masters degree from the California Institute of Technology in Quantum Chemistry. There, I worked on developing excited-state methods for periodic systems. I also expanded my skill-set through taking classes in machine learning and data science. I take special interest in how these quantitative methods can be used to solve scientific problems.
I also hold a Bachelors Degree in Chemistry from UCI, where I graduated Summa Cum Laude. During my undergraduate study, I was recognized for a number of academic achievements. A list of some accolades can be found in the “Media” section.
Aside from scientific research, I also aspire to become a worthy mentor and educator to help improve scientific literacy in America. I hope to be of service not just to college-age students in the lecture hall, but also to younger students with interest in STEM fields.
In addition to my academic pursuits, I like to sing and play the piano. My musical influences come from many genres, but I am especially fond of artists like Bill Evans and Chet Baker.
When I can, I also enjoy traveling. You can catch a glipse of my adventures in the “Photos” section.
Thank you for your interest, and please do not hesitate to contact me through any means listed on the “Contact” page.


Events
Weekly Meeting
Phoenix Spark Working Lunch
Phoenix Spark Lab Building 181 (6 ARS 1st Floor) Travis AFB, CA
12:00 pm, Fridays
An open space for current and potential participants to update ongoing projects and pitch ideas.
More InformationSTEAM Library Activities
Mitchell Memorial Library, 510 Travis Ave Travis AFB, CA 94535
3:00-5:00 pm, Wednesdays
Activities for students to learn about Science, Technology, Engineering, Art, and Mathematics (STEAM). Past events include designing and building a toy roller coaster to learn about physics. Children 8 years and under must be accompanied by an adult.
More InformationConferences
AFWERX FUSION XPERIENCE
Las Vegas, NV
July 23-24, 2019
The AFWERX FUSION XPERIENCE is a two-day showcase and conference hosted by AFWERX in collaboration with the United States Air Force. This annual flagship event brings together industry, individual innovators, academia, investors, as well as, military and government team members. The goal of this event is to present, contract, and fund innovative solutions for Air Force areas of interest and facilitate an environment of connection and collaboration.
More InformationMIT Media Lab
Cambridge, MA
June 11-12, 2019
AI and robotics are driving rapid and radical workplace transformation across all industries, for companies large and small. These and other emerging technologies, like advanced manufacturing and AR/VR, are changing jobs ranging from manufacturing to medicine to retail. EmTech Next examines the technology behind these global trends and their implications for the future of work. It will delve into their potential to empower the human workforce and open up new areas of economic growth, while also exploring their unintended consequences.
More InformationDefense Executive Technology Entrepreneurs Course (DETEC)
Austin, TX
March 26-29, 2019
DETEC is not a traditional classroom training course. It is modeled after executive education seminars from top MBA programs. The format of the course combines seminar-style discussion, dynamic presentations from experienced leaders, interactive design thinking workshops, and in-person events with tech executives and leaders across government. The fast-paced DETEC course will arm participants with an actionable plan to drive innovation across their organization. Participants will workshop their existing challenges throughout a three day program. Hands-on expert-led workshops help leaders identify the right tech solutions, lead effective implementation and measurement, and manage transformation across teams and stakeholders. Leaders will leave the DETEC program with practical knowledge, a tactical plan tailored to their organization, and an exceptional network of peers and coaches to provide ongoing support.
More InformationNVIDIA’s GPU Technology Conference (GTC)
San Jose, CA
March 18-22, 2019
GTC is the premier AI and deep learning conference series, providing you with training, insights, and direct access to experts from NVIDIA and other leading organizations.
More InformationCourses
NSIN X-Force Fellowship Pilot Program
Ongoing
National Security Innovation Network (formerly MD5) X-Force Fellowship Pilot Program is a funded summer fellowship opportunity for university students to embed with military commands for applied national security problem solving.
More InformationNSIN Bootcamp
Ongoing
National Security Innovation Network (formerly MD5) Bootcamp is a 4-day course in which learners are introduced to methods for innovation in the context of real-world problems facing their command. The course uses human-centered design (HCD) for problem-framing and problem-solving, as well as Lean LaunchPad for hypothesis development and hypothesis testing. Combining these methods allows commanders to capitalize on the talent in their organization and receive an initial framework of how a solution might be viable outside the classroom. Participants use framework tools like the Mission Model Canvas (MMC) and Minimum Viable Product (MVP) to capture and present their ideas. At the end of the course, project teams pitch potential solutions to the command-level problem sponsor. The commander can act on the momentum and ideas generated by the Bootcamp with the NSIN representative at the pitch event. NSIN offers programming to assist with collaboration and move ideas generated from Bootcamps into actionable outcomes that reach the service member.
More InformationSacramento Hacker Lab
1715 I St, Sacramento
Ongoing
An all-in-one makerspace, coworking facility, and startup incubator. We bring people, training, and advanced prototyping equipment together under one roof, giving innovators the opportunity to bring their vision to life.
More InformationOPM Center for Leadership Development
Throughout the U.S.
Ongoing
The OPM’s Center for Leadership Development is dedicated to developing great leaders for the Federal Government. Our faculty and facilitators—drawn from America’s elite corps of leadership development professionals—provide personalized services to help you focus on the developmental opportunities that will propel you to an outstanding level of performance excellence.
More Information


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface PhysicsActuator
A physics engine representation of an actuator: can actuate two module components relative to each other. Has sensors to sense its state, and embeds its own controller.
| Method Summary | |
|---|---|
boolean |
activate(float goalValue)
Activate this actuator - to go for a particular goal value |
void |
disactivate()
Stop the actuator |
float |
getEncoderValue()
Get the encoder value of this actuator |
boolean |
isActive()
Returns true if this actuator is active |
void |
reset()
Reset the simulated actuator to its initial configuration |
void |
setErrorThreshold(float maxError)
Set the threshold for the precision of the actuator Note that too low a threshold will case the actuator newer to converge |
void |
setModel(Actuator actuator)
Set the abstract actuator representation for this physics entity |
| Methods inherited from interface ussr.physics.PhysicsEntity |
|---|
clearDynamics, getPosition, getRotation, setPosition, setRotation |
| Method Detail |
|---|
void setModel(Actuator actuator)
actuator
- the actuator to associate with this physics entityboolean isActive()
boolean activate(float goalValue)
void setErrorThreshold(float maxError)
maxError
- the error thresholdvoid disactivate()
void reset()
reset
in interface PhysicsEntity
float getEncoderValue()
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


{% extends "base.html" %} {% load static %} {% block content %
Error: 500
Return back to safety using this button
If you got here via the contact form, see README.md for more information


Our daily lives are now in constant contact with cloud computing without even realizing it. How does cloud computing come into play though? This website offers in dept, up to date information about this modern technology.
-STPA Cloud Computing


 This action cannot be reversed!
Cancel
Permanently Delete LIVE PAGE


Latest submitted packages by our community
Search results for: {{ q | capitalize }}
Nothing found! Please try searching with different keyword
{{gist.name.trunc(28)}}
{{gist.description.trunc(110)}}
{{gist.name.trunc(28)}}
{{gist.description.trunc(110)}}


{# Copyright (c) 2014 The Pycroft Authors. See the AUTHORS file. This file is part of the Pycroft project and licensed under the terms of the Apache License, Version 2.0. See the LICENSE file for details. #} {% extends "layout.html" %} {% import "macros/resources.html" as resources %} {% block page_css %} {% endblock %} {% set container_class = "container-fluid" %} {% block content %}
{{ _("Neue Eigenschaftsgruppe") }}
{% if property_groups -%}


samtools
Tools for handling high-throughput sequencing (genomics) data.
Used for reading/writing/editing/indexing/viewing of data in SAM/BAM/CRAM format.
More information: home page
- Convert a SAM input file to BAM stream and save to file:
samtools view -S -b input.sam > output.bam
- Take input from `stdin` (-) and print the SAM header and any reads overlapping a specific region to `stdout`:
other_command | samtools view -h - chromosome:start-end
- Sort file and save to BAM (the output format is automatically determined from the output file's extension):
samtools sort input -o output.bam
- Index a sorted BAM file (creates sorted_input.bam.bai):
samtools index sorted_input.bam
- Print alignment statistics about a file:
samtools flagstat sorted_input
- Count alignments to each index (chromosome / contig):
samtools idxstats sorted_indexed_input
- Merge multiple files:
samtools merge output input1 input2 …
- Split input file according to read groups:
samtools split merged_input


Class: Aws::FSx::Types::OntapVolumeConfiguration
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb |
Overview
The configuration of an Amazon FSx for NetApp ONTAP volume.
Constant Summary
Instance Attribute Summary
-
#copy_tags_to_backups ⇒ Boolean
rw
A boolean flag indicating whether tags for the volume should be copied to backups.
-
#flex_cache_endpoint_type ⇒ String
rw
Specifies the FlexCache endpoint type of the volume.
-
#junction_path ⇒ String
rw
Specifies the directory that network-attached storage (NAS) clients use to mount the volume, along with the storage virtual machine (SVM) Domain Name System (DNS) name or IP address.
-
#ontap_volume_type ⇒ String
rw
Specifies the type of volume.
-
#security_style ⇒ String
rw
The security style for the volume, which can be
UNIX
,NTFS
, orMIXED
. -
#size_in_megabytes ⇒ Integer
rw
The configured size of the volume, in megabytes (MBs).
-
#snaplock_configuration ⇒ Types::SnaplockConfiguration
rw
The SnapLock configuration object for an
::Aws::FSx
for ONTAP SnapLock volume. -
#snapshot_policy ⇒ String
rw
Specifies the snapshot policy for the volume.
-
#storage_efficiency_enabled ⇒ Boolean
rw
The volume's storage efficiency setting.
-
#storage_virtual_machine_id ⇒ String
rw
The ID of the volume's storage virtual machine.
-
#storage_virtual_machine_root ⇒ Boolean
rw
A Boolean flag indicating whether this volume is the root volume for its storage virtual machine (SVM).
-
#tiering_policy ⇒ Types::TieringPolicy
rw
The volume's
TieringPolicy
setting. -
#uuid ⇒ String
rw
The volume's universally unique identifier (UUID).
Instance Method Summary
Instance Attribute Details
#copy_tags_to_backups ⇒ Boolean
(rw)
A boolean flag indicating whether tags for the volume should be copied to backups. This value defaults to false. If it's set to true, all tags for the volume are copied to all automatic and user-initiated backups where the user doesn't specify tags. If this value is true, and you specify one or more tags, only the specified tags are copied to backups. If you specify one or more tags when creating a user-initiated backup, no tags are copied from the volume, regardless of this value.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#flex_cache_endpoint_type ⇒ String
(rw)
Specifies the FlexCache endpoint type of the volume. Valid values are the following:
NONE
specifies that the volume doesn't have a FlexCache configuration.NONE
is the default.ORIGIN
specifies that the volume is the origin volume for a FlexCache volume.CACHE
specifies that the volume is a FlexCache volume.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#junction_path ⇒ String
(rw)
Specifies the directory that network-attached storage (NAS) clients
use to mount the volume, along with the storage virtual machine
(SVM) Domain Name System (DNS) name or IP address. You can create a
JunctionPath
directly below a parent volume junction or on a
directory within a volume. A JunctionPath
for a volume named
vol3
might be /vol1/vol2/vol3
, or /vol1/dir2/vol3
, or even
/dir1/dir2/vol3
.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#ontap_volume_type ⇒ String
(rw)
Specifies the type of volume. Valid values are the following:
RW
specifies a read/write volume.RW
is the default.DP
specifies a data-protection volume. You can protect data by replicating it to data-protection mirror copies. If a disaster occurs, you can use these data-protection mirror copies to recover data.LS
specifies a load-sharing mirror volume. A load-sharing mirror reduces the network traffic to a FlexVol volume by providing additional read-only access to clients.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#security_style ⇒ String
(rw)
The security style for the volume, which can be UNIX
, NTFS
, or
MIXED
.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#size_in_megabytes ⇒ Integer
(rw)
The configured size of the volume, in megabytes (MBs).
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#snaplock_configuration ⇒ Types::SnaplockConfiguration (rw)
The SnapLock configuration object for an ::Aws::FSx
for ONTAP SnapLock
volume.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#snapshot_policy ⇒ String
(rw)
Specifies the snapshot policy for the volume. There are three built-in snapshot policies:
default
: This is the default policy. A maximum of six hourly snapshots taken five minutes past the hour. A maximum of two daily snapshots taken Monday through Saturday at 10 minutes after midnight. A maximum of two weekly snapshots taken every Sunday at 15 minutes after midnight.default-1weekly
: This policy is the same as thedefault
policy except that it only retains one snapshot from the weekly schedule.none
: This policy does not take any snapshots. This policy can be assigned to volumes to prevent automatic snapshots from being taken.
You can also provide the name of a custom policy that you created with the ONTAP CLI or REST API.
For more information, see Snapshot policies in the Amazon ::Aws::FSx
for NetApp ONTAP User Guide.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#storage_efficiency_enabled ⇒ Boolean
(rw)
The volume's storage efficiency setting.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#storage_virtual_machine_id ⇒ String
(rw)
The ID of the volume's storage virtual machine.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#storage_virtual_machine_root ⇒ Boolean
(rw)
A Boolean flag indicating whether this volume is the root volume for
its storage virtual machine (SVM). Only one volume on an SVM can be
the root volume. This value defaults to false
. If this value is
true
, then this is the SVM root volume.
This flag is useful when you're deleting an SVM, because you must
first delete all non-root volumes. This flag, when set to false
,
helps you identify which volumes to delete before you can delete the
SVM.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#tiering_policy ⇒ Types::TieringPolicy (rw)
The volume's TieringPolicy
setting.
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end
#uuid ⇒ String
(rw)
The volume's universally unique identifier (UUID).
# File 'gems/aws-sdk-fsx/lib/aws-sdk-fsx/types.rb', line 6594
class OntapVolumeConfiguration < Struct.new( :flex_cache_endpoint_type, :junction_path, :security_style, :size_in_megabytes, :storage_efficiency_enabled, :storage_virtual_machine_id, :storage_virtual_machine_root, :tiering_policy, :uuid, :ontap_volume_type, :snapshot_policy, :, :snaplock_configuration) SENSITIVE = [] include Aws::Structure end


Kahuku tips Campbell in wild finish to reach Open Divison state football final | Honolulu Star-Advertiser
Tomasi Pasi tipped away a 2-point conversion pass to give No. 3 Kahuku a 21-19 win over No. 5 Campbell on Friday night in the Open Division semifinals of the First Hawaiian Bank/HHSAA Football State Championships at Aloha Stadium. Read more
Mahalo for reading the Honolulu Star-Advertiser!
You're reading a premium story. Read the full story with our Print & Digital Subscription.
Already a subscriber? Log in now to continue reading this story.
Print subscriber but without online access? Activate your Digital Account now.


WITNESS LIST Insurance Committee May 9, 2006-11:00A HB 7/ Workers' Comp On: Betts, Albert (Texas Department of Insurance, Division of Wokers' Compensation) Bragg, David (Vista Medical Center Hospital) Darwin, Norman (Office of Injured Employee Counsel) Geeslin, Mike (Texas Department of Insurance) Lazaretti, Margaret (Texas Department of Insurance) Lee, Amy (Texas Department of Insurance)


A very minimal class that limits the number of elements that can be added to it.
class SizedList<T> : LinkedList<T>
fun <T> cartesianProduct(lists: List<List<T>>): List<List<T>>


Someone who works in IT and enjoys building software. Working out of Singapore since 2012, I have experienced the meh-ness of electrical engineering followed by the sheer high of developing software applications. I like to dabble frequently in technological experiments. Hence, I do not have any overarching preference for any programming language or framework or device. (although I do most of my work in Python, Objective-C and Java). Recently, I have taken to WordPress design. It started off as a way for me to get this site up and running.
You may ask me anything. I'd love to discuss tech, startups and pretty much anything
related to code.
def factorial(n):
if n <= 1:
return 1
return n * n-1
© 2017 Vikram Bahl


--- layout: post title: Eighteen Forty Three date: '2010-10-25T00:00:00-04:00' tags: - '2010' tumblr_url: http://poetry.liabogoev.com/post/49867273035/eighteen-forty-three ---
I don’t know what time it is
I’m sitting at the Starbucks
The one down Ames
Listening to the gossip babble
Of the girl parked next to me blathering on and on
to the two blond twins sitting next to her
About Charles and the dance class and her hurt knee
As the barista shouts out drinks that break through the fragile
wall of concentration in my brain like a jackhammer
while jazz blares too loud over speakers
drowned out only by the annoying ring of the
blackberries of pretentious Cambridge businessmen
How urgent is their business anyway
Ian’s hands rub soothing circles on my back
And I’m just annoyed because nothing’s working out right
But the people around me work just fine
Another woman at the long wood table
typing deliberately and oblivious to the mundane around her
even as it swallows me
I see a Jack Florey with his pink hair orders coffee just as cool as can be
Walks out not a care in the world
And I look at the smiling mermaid and think
How I wish I could be you
Instead I sit writing in deep blue ink on white paper
With perforated dotted strips and wondering where it all comes from.