(DIR) petergarner.net gopher root
(DIR) petergarner.net Cybertech root
--
-- A fine collection of Technically-oriented PDFs (Papers, Specs,
-- Decks, Manuals, etc) compiled by Trent Nelson and dehain
--
-- Visit Github for the full set which also includes non-PDF files
--
-- Links: https://github.com/tpn/pdfs
-- https://github.com/tpn
-- https://github.com/dehain
--
(BIN) 100G Networking Technology Overview - Slides - Toronto (August 2016)
(BIN) 2018 CppCon Unwinding the Stack - Exploring how C++ Exceptions work on Windows - James McNellis
(BIN) 37 Million Compilations - Investigating Novice Programming Mistakes in Large-Scale Student Data (fp1187-altadmri)
(BIN) 5-Level Paging and 5-Level EPT - Intel - Revision 1.0 (December, 2016)
(BIN) 5-Level Paging and 5-Level EPT - Intel - Revision 1.1 (May, 2017)
(BIN) A Block-sorting Lossless Data Compression Algorithm - May 10th, 1994 (SRC-RR-124)
(BIN) A Brief Introduction to Neural Networks (neuronalenetze-en-zeta2-2col-dkrieselcom)
(BIN) A Brief Introduction to the Standard Annotation Language (SAL) - 2006
(BIN) A Brief Tutorial on Database Queries, Data Mining, and OLAP (hamel-197-manuscript-final)
(BIN) Abstract Algebra - 2016 (aata-20160809-sage-7.3)
(BIN) Abstract Rendering - Out-of-core Rendering for Information Visualization (2014)
(BIN) Abusing Mach on Mac OS X - May, 2006 (uninformed_v4a3)
(BIN) A Case Study in Optimizing HTM-Enabled Dynamic Data Structures - Patricia Tries (2015)
(BIN) A Catalogue of Optimizing Transformations (1971-allen-catalog)
(BIN) Accelerating Network Receive Processing - Intel IO Acceleration Technology (ols2005v1-pages-289-296)
(BIN) Achieving Full-Motion Video on the Nintnedo 64 -GDM (September 2000)
(BIN) A Comparison of Programming Languages in Economics (16-Jun-2014)
(BIN) A Comparison of Software and Hardware Techniques for x86 Virtualization - Oct 2015 (asplos235_adams)
(BIN) A comparison of SPDY and HTTP performance - Microsoft Research (2012)
(BIN) A Compilation Target for Probabilistic Programming Languages - 2014 (paige14)
(BIN) A comprehensive study of Convergent and Commutative Replicated Data Types
(BIN) A Comprehensive Study of Main-Memory Partitioning and its Application to Large-Scale Comparison- and Radix-Sort (sigmod14I)
(BIN) A Compressed Suffix Tree Based Implementation with Low Peak Memory Usage (2014)
(BIN) A Course in Machine Learning (ciml-v0_9-all)
(BIN) A Crash Course in x86 Assembly for Reverse Engineers - SensePost (2014)
(BIN) Adaptive Insertion Policies for High Performance Caching (ISCA-2007-Qureshi-SetDuelingControl)
(BIN) Adaptive Ray Packet Reordering - 2008 (reorder_rt08)
(BIN) Adaptive String Dictionary Compression in In-Memory Column-Store Database Systems (2014)
(BIN) Adding Lock Elision to Linux - Slides (2012)
(BIN) AddressSanitizer - A Fast Address Sanity Checker (atc12-final39)
(BIN) A Detailed Analysis of the Component Object Model - 1989 (Muijadi_okstate_0664M_1681)
(BIN) A Dive in to Hyper-V Architecture and Vulnerabilities
(BIN) A Dive in to Hyper-V Architecture and Vulnerabilities - Slides (BlackHat 2018)
(BIN) A Durable Main-Memory Index Using Flash
(BIN) Advanced Bloom Filter Based Algorithms for Efficient Approximate Data De-Duplication in Streams - 17th Dec 2012 (1212.3964v1)
(BIN) Advanced Data Structures - MIT 6.851 (2012)
(BIN) Advanced Topics in CUDA - Slides (2011)
(BIN) Advances in Cloud-Scale Machine Learning for Cyber-Defense - Russinovich 2017 (exp-t11-advances-in-cloud-scale-machine-learning-for-cyber-defense)
(BIN) Advances in Memory Management for Windows - October 12, 2007 (136_MemMgt)
(BIN) A Family of Perfect Hashing Methods - 1996 (TR0242)
(BIN) A Faster Cutting Plane Method and its Implications for Combinatorial and Convex Optimization - MIT - 2015 (1508.04874)
(BIN) A Fast, Minimal Memory, Consistent Hash Algorithm (1406.2294)
(BIN) A Fast, Minimal Memory, Consistent Hash Algorithm (1406.2294v1)
(BIN) A Fast x86 Implementation of Select - 2017 (1706.00990)
(BIN) A Few Billion Lines of Code Later - Using Static Analysis to Find Bugs in the Real World - ACM - 2010 (BLOC-coverity)
(BIN) A Few Experiments with Intel's Cache Allocation Technology - Slides (2015)
(BIN) Affinity Accept - Improving Network Connection Locality on Multicore Systems
(BIN) A File Comparison Program - 1985 (10.1.1.189.70)
(BIN) A File is Not a File - Understanding IO Behavior of Apple Desktop Applications (2011)
(BIN) A First Encounter with Machine Learning - 2011 (IntroMLBook)
(BIN) A Forensic Analysis of CSG 11 Encounter with an Anomalous Aerial Vehicle
(BIN) A Framework for Building Extensible C++ Class Libraries - 1993
(BIN) Agner Fog - Calling Conventions for different C++ compilers and operating systems (2013-09-04)
(BIN) Agner Fog - Calling Conventions for different C++ compilers and operating systems (2017-05-01)
(BIN) Agner Fog - C++ vector class library (2013)
(BIN) Agner Fog - C++ vector class library v2 (2019)
(BIN) Agner Fog - Instruction Tables (2013-04-03)
(BIN) Agner Fog - Instruction Tables (2018-04-09)
(BIN) Agner Fog - Microarchitecture of Intel, AMD and VIA CPUs - An optimization guide for assembly programmers and compiler makers (2013-09-04)
(BIN) Agner Fog - Microarchitecture of Intel, AMD and VIA CPUs - An optimization guide for assembly programmers and compiler makers (2018-04-09)
(BIN) Agner Fog - Optimizing Software in C++ (2014-08-07)
(BIN) Agner Fog - Optimizing Software in C++ (2017-05-02)
(BIN) Agner Fog - Optimizing Subroutines in Assembly Language - An optimization guide to x86 platforms (2013-09-28)
(BIN) Agner Fog - Optimizing Subroutines in Assembly Language - An optimization guide to x86 platforms (2017-05-01)
(BIN) A GPU-friendly Skiplist Algorith - 2014 (GPUSkiplist)
(BIN) A History of Modern 64-bit Computing - Feb 2007 (CSEP590A)
(BIN) Algebra, Topology, Differential Calculus, and Optimization Theory For Computer Science and Machine Learning - 2019 (math-deep)
(BIN) Algorithms for Random 3-SAT
(BIN) Algorithms for Routing Lookups and Packet Classification - PhD Thesis (Pankaj Gupta, 2000)
(BIN) A Little Journey Inside Windows Memory
(BIN) Allocation Removal by Partial Evaluation in a Tracing JIT - 2010 (bolz-allocation-removal)
(BIN) Almost Random Graphs with Simple Hash Functions - Slides (2007)
(BIN) A Locality-Sensitive Hash for Real Vectors (10.1.1.215.7690)
(BIN) A Lock-Free Wait-Free Hash Table - Slides (070221_LockFreeHash)
(BIN) A Look at Intel's Dataplane Development Kit (2014)
(BIN) Alpha AXP Architecture - 1992 (vol4num4art1)
(BIN) Alternating Coding and its Decoder Architectures for Unary-Prefixed Codes - PhD Thesis, Shang Xue (2005)
(BIN) A Malloc Tutorial (Feb 16, 2009)
(BIN) A Mathematical Theory of Communication (1948)
(BIN) A Mathematician's Lament - Paul Lockhart
(BIN) AMD64 Architecture Programmer's Manual - Volume 1 - Application Programming (24592, r3.21, Oct-2013)
(BIN) AMD64 Architecture Programmer's Manual - Volume 2 - System Programming (24593, r3.24, Oct-2013)
(BIN) AMD64 Architecture Programmer's Manual - Volume 2 - System Programming (24593, r3.25, Jun-2015)
(BIN) AMD64 Architecture Programmer's Manual - Volume 3 - General-Purpose and System Instructions (24594, r3.21, Oct-2013)
(BIN) AMD64 Architecture Programmer's Manual - Volume 3 - General-Purpose and System Instructions (24594, r3.22, Jun-2015)
(BIN) AMD64 Architecture Programmer's Manual - Volume 3 - General-Purpose and System Instructions (24594, r3.25, Dec-2017)
(BIN) AMD64 Architecture Programmer's Manual - Volume 4 - 128-Bit and 256-Bit Media Instructions (26568, r3.18, Oct-2013)
(BIN) AMD64 Architecture Programmer's Manual - Volume 4 - 128-Bit and 256-Bit Media Instructions (26568, r3.19, Jun-2015)
(BIN) AMD64 Architecture Programmer's Manual - Volume 5 - 64-Bit Media and x87 Floating-point Instructions (26569, r3.12, Mar-2012)
(BIN) AMD64 Architecture Programmer's Manual - Volume 5 - 64-Bit Media and x87 Floating-point Instructions (26569, r3.13, May-2013)
(BIN) AMD - AMD64 Archictecture Programmer's Manual - Volume 4 - 128-bit and 256-bit Media Instructions - Rev 3.23 - Feb 2019 (26568)
(BIN) AMD - AMD64 Architecture Programmer's Manual - Volume 1 - Application Programming - Rev 3.22 - Dec 2017 (24592)
(BIN) AMD - AMD64 Programmer's Manual - Volume 2 - System Programming - Rev 3.30 - Sept 2018 (24593)
(BIN) AMD - AMD64 Programmer's Manual - Volume 3 - General Purpose and System Instructions - Rev 3.26 - May 2018 (24594)
(BIN) AMD - BIOS and Kernel Developer's Guide (BKDG) for AMD Family 15h Models 70h-7Fh Processors - Rev 3.09 - June 20th, 2018 (55072)
(BIN) AMD - CPUID
(BIN) AMD - GCN3 Instruction Set Architecture - Graphics Core Next Architecture, Generation 3 (Revision 1.0, March 2015)
(BIN) AMD - Preliminary Processor Programming Reference (PPR) for AMD Family 17h Models 00h-0Fh Processors - Rev 1.14 - April 15th, 2017 (54945)
(BIN) AMD - Software Optimization Guide for AMD Family 15h Processors - Rev 3.08 - Jan 2014 (47414_15h_sw_opt_guide)
(BIN) AMD - System Programming (24593)
(BIN) A Method for the Construction of Minimum-Redundancy Codes - Huffman (1952)
(BIN) Analysing the Performance of GPU Hash Tables for State Space Exploration - 2017 (1712.09494)
(BIN) Analysis of B-tree Data Structure and its Usage in Computer Forensics (484192.B-tree)
(BIN) Analysis of GS protections in Microsoft Windows Vistal - Symantec
(BIN) Analyzing Contextual Bias of Program Execution on Modern CPUs (Lars Kirkholt Melhus, NTNU, June 2013)
(BIN) Analyzing General Purpose Computing Performance on GPU - Thesis (2015)
(BIN) Analyzing GPGPU Pipeline Latency - Poster - 2014 (poster_andresch_acaces2014)
(BIN) Analyzing Runtime and Size Complexity of Integer Programs - Microsoft Research (2016)
(BIN) Analyzing your game performance using Event Tracing for Windows
(BIN) A Nanopass Framework for Compiler Education
(BIN) An Approach for Minimal Perfect Hash Functions for Very Large Databases (tr06)
(BIN) Anatomy of High-Performance Matrix Multiplication - 2008 (gotoPaper)
(BIN) An Elegant Algorithm for the Construction of Suffix Arrays (2014)
(BIN) An Evaluation of Network Stack Parallelization Strategies in Modern Operating Systems
(BIN) A New Basis for Shifters in General-Purpose Processors for Existing and Advanced Bit Manipulations - 2009 (IEEE_TC09_NewBasisForShifters)
(BIN) An Experimental Exploration of Marsaglia's Xorshift Generators, Scrambled - 13 Oct 2016 (1402.6246)
(BIN) An In-Depth Analysis of Disassembly on Full-Scale x86-x64 Binaries - 2016 (sec16_paper_andriesse)
(BIN) An Informal Analysis of Perfect Hash Function Search (1989)
(BIN) An Introduction to Computational Networks and the Computational Network Toolkit - Microsoft (CNTKBook-20160121)
(BIN) An Introduction To Statistical Learning with Applications in R (ISLR Seventh Printing)
(BIN) An Introduction To Statistical Learning with Applications in R (ISLR Sixth Printing)
(BIN) An NUMA API for Linux - Andi Kleen, Aug 2004
(BIN) An Optimal Algorithm for Generating Minimal Perfect Hash Functions - 1992 (10.1.1.51.5566)
(BIN) A Novel Hybrid Quicksort Algorithm Vectorized using AVX-512 on Intel Skylake - 2017 (Paper_44-A_Novel_Hybrid_Quicksort_Algorithm_Vectorized)
(BIN) An Overview of Linux Kernel Locking Improvements (August 2014)
(BIN) Answering Reachability Queries on Large Directed Graphs - INF-SCR-10-10 (September, 2010)
(BIN) Anti-Debugging Reference - Peter Ferrie (4 May 2011)
(BIN) A NUMA API for Linux - Novell (2005)
(BIN) A Parallel Page Cache- IOPS and Caching for Multicore Systems
(BIN) A PlusCal User's Manual - C-Syntax Version 1.8 (31 Aug 2018)
(BIN) Applications of Finite Automata Representing Large Vocabularies - 1993 (10.1.1.56.5272)
(BIN) Applications of Finite Geometry in Coding Theory and Cryptography
(BIN) Applying the Proactor Pattern to High-Performance Web Servers
(BIN) Approximate Hypergraph Partitioning and Applications (2007)
(BIN) A Practical Guide to Support Vector Classification
(BIN) A Practical Minimal Perfect Hashing Method (2005)
(BIN) A Primer on Memory Consistency and Cache Coherence (10.1.1.225.9278)
(BIN) A Probabilistic Theory of Deep Learning (1504.00641v1)
(BIN) A Proposal for Hardware Assisted Arithmetic Overflow Detection - 2010 - Slides (Mihocka-Troeger-CGO-WISH-2010_final)
(BIN) A Proposal for Hardware Assisted Arithmetic Overflow Detection for Array and Bitfield Operations (LazyOverflowDetect_Final)
(BIN) A Quick Guide To LaTeX
(BIN) Architectural Support for SWAR Text Processing with Parallel Bit Streams - The Inductive Doubling Principle - 2009 (p337-cameron)
(BIN) Architecture of a Database System - 2007 (fntdb07-architecture)
(BIN) A Relational Model of Data for Large Shared Data Banks - E.F. Codd (1970)
(BIN) A Reliable Randomized Algorithm for the Closest-Pair Problem - 1997 (CP-11.4.1997)
(BIN) ARIES - A Transaction Recovery Method Supporting Fine-Granularity Locking and Partial Rollbacks Using Write-Ahead Logging (1992)
(BIN) ARM - Instruction Set Quick Reference Card (QRC0001_UAL.)pdf
(BIN) Array Layouts for Comparison-based Searching (March 14, 2017)
(BIN) Array Layouts for Comparison-based Searching (September, 2015)
(BIN) Array programming with NumPy - Nature - 2020 (s41586-020-2649-2)
(BIN) Art Of Intel x86 Assembly
(BIN) A Scalable and Explicit Event Delivery Mechanism for UNIX
(BIN) A Scalable Concurrent malloc Implementation for FreeBSD (jemalloc)
(BIN) A Scalable Lock-free Stack Algorithm (2004)
(BIN) A Sense of Self for Unix Processes - 1996 (ieee-sp-96-unix)
(BIN) A Seven-Dimensional Analysis of Hashing Methods and its Implications on Query Processing - 2015 (p249-richter)
(BIN) Asim - A Performance Model Framework (2002.02.computer.asim)
(BIN) ASLR on the Line - Practical Cache Attacks on the MMU - 2017 (anc_ndss17)
(BIN) Aspects Related to Data Access and Transfer in CUDA - Slides - 2014 (TR-2014-09)
(BIN) Assembly Language for Beginners (AL4B-EN)
(BIN) Assessing the Relationship between Software Assertions and Code Quality - An Empirical Investigation (tr-2006-54)
(BIN) Assessment of Windows Vista Kernel-Mode Security - Matthew Conover (Symantec)
(BIN) A study of code abstraction (Patrick Lambert - Oct 15th, 2014)
(BIN) A Study of Wheat and Chaff in Source Code (1502.01410v1)
(BIN) A Survey of Rollback-Recovery Protocols in Message-Passing Systems (10.1.1.52.4299)
(BIN) Asynchronous Teams - Cooperation Schemes for Autonomous Agents
(BIN) A Systematic Evaluation of Transient Execution Attacks and Defenses - 15th May 2019 (1811.05441)
(BIN) ATOM - A System for Building Customized Program Analysis Tools - 1994
(BIN) A Tool for the Symbolic Execution of Linux Binaries - PySymemu (Slides)
(BIN) A Truly Concurrent Semantics for the K Framework Based on Graph Transformations - Slides (serbanuta-rosu-2012-icgt-slides)
(BIN) Attacking the Windows Kernel - 2007
(BIN) A Tunable Compression Framework for Bitmap Indices (Guzun_ICDE_2014)
(BIN) A Tutorial on Bayesian Optimization of Expensive Cost Functions, with Application to Active User Modeling and Hierarchical Reinforcement Learning - 12th Dec 2016 (bayopt)
(BIN) Automated Instruction Stream Throughput Prediction for Intel and AMD Microarchitectures - 2018 (1809.00912)
(BIN) Automatically Proving Termination and Memory Safety for Programs with Pointer Arithmetic - Microsoft Research (2016)
(BIN) Automatic Self-Allocating Threads on an SGI Challenge (10.1.1.37.3403)
(BIN) AutoML - Chapter 01 - Hyperparameter Optimization (2018)
(BIN) A Versatile Graph Structure for Edge-Oriented Graph Algorithms - 1987 (Ebert1987AVD)
(BIN) A Very Fast Substring Search Algorithm - 1999 (p132-sunday)
(BIN) Avoiding AVX to SSE Transition Penalties
(BIN) A Wavelet Tree Based FM-Index for Biological Sequences in SeqAn (January 30, 2012)
(BIN) A Way Forward in Parallelising Dynamic Languages (PyPy Position Paper)
(BIN) Background, Motivation, and a Retrospective View of the BLAS (Lawson_BLAS)
(BIN) Backward Search FM-Index (Full-text Index in a Minute Space) - Slides
(BIN) Balanced Families of Perfect Hash Functions and Their Applications - 2007
(BIN) Bash Redirections - Cheat Sheet
(BIN) Basic Linear Algebra Subprograms for Fortran Usage - BLAS (1979)
(BIN) Basics of Compiler Design - Anniversary Edition
(BIN) Battle of SKM and IUM - How Windows 10 Rewrites OS Architecture - Alex Ionescu - 2015 (blackhat2015)
(BIN) Bayesian Data Analysis - Third Edition (13th Feb 2020)
(BIN) Bayesian Reasoning and Machine Learning (181115)
(BIN) Benchmarking a B-tree Compression Method
(BIN) Benefits of IO Acceleration Technology in Clusters
(BIN) Best Practices for Gathering Optimizer Statistics for Oracle 12c (June 2013)
(BIN) Best Practices for Vectorization - Getting Ready for Intel AVX-512 (2015)
(BIN) Better Bitmap Performance with Roaring Bitmaps (2014)
(BIN) Better Performance at Lower Occupancy - Slides - 2010 (volkov10-GTC)
(BIN) Better with Fewer Bits - Improving the Performance of Cardinality Estimation of Large Data Streams (INFOCOM2017)
(BIN) Beyond Block IO - Rethinking Traditional Storage Primitives (ouyangx-hpca2011)
(BIN) Beyond Block IO - Rethinking Traditional Storage Primitives (ouyangx-hpca2011-slides)
(BIN) BGP in 2013 (and a bit of 2014) - Slides (156-2014-05-12-bgp2013)
(BIN) Big Data - New Tricks for Econometrics
(BIN) BigQuery Technical Whitepaper - Google
(BIN) Binarized Neural Networks - Training Deep Neural Networks with Weights and Activations Constrained to +1 or -1 - 2016 (1602.02830v3)
(BIN) Binarized Neural Networks- Training Deep Neural Networks with Weights and Activations Constrained to +1 or -1 - 2016 (1602.02830v3)
(BIN) Binary Coding (2017)
(BIN) Binary Combinatorial Coding (2003)
(BIN) Binary Search Tree with SIMD Bandwidth Optimizations Using SSE (Preso06-SIMDTree)
(BIN) BIOS and Kernel Developer's Guide for AMD Athlon 64 and AMD Opteron Processors - r3.30 Feb 2006
(BIN) Bitcoin - A Peer-to-Peer Electronic Cash System
(BIN) Bitmap Graphics and Bitblit - Course Notes - SIGGRAPH 1984 (pike84bitblt)
(BIN) Bitmap Graphs SIGGRAPH84 Course Notes (pike84bitblt)
(BIN) Bitmap Index Design and Evaluation - 1998 (P355)
(BIN) Bitmap Index Design Choices and Their Performance Implications (LBNL-62756)
(BIN) Bitmap Indexing and Related Techniques - Slides
(BIN) Bitmap Indices for Data Warehouses
(BIN) Bit Operations (Ray Seyfarth 2011)
(BIN) BitPath - Label Order Constrained Reachability Queries over Large Graphs - 1203.2886 (13th March, 2012)
(BIN) Blackout - What Really Happened - Slides (2007)
(BIN) Blade - A Data Center Garbage Collector - 2015 (1504.02578)
(BIN) BLAKE2 - Simpler, Smaller, Fast as MD5 (2013-01-29)
(BIN) Blogel - A Block-Centric Framework for Distributed Computation on Real-World Graphs (2014)
(BIN) Boosting Vector Calculus with the Graphical Notation - 3 Nov 2019 (1911.00892)
(BIN) Bounds Checking on the GPU - Futhark (hlpp20)
(BIN) BPF - In-memory Virtual Machine (bpf_collabsummit_2015feb20)
(BIN) Branch and Data Herding - Reducing Control and Memory Divergence for Error-tolerant GPU Applications (tmm12_preprint)
(BIN) Branch Prediction and the Performance of Interpreters - Don't Trust the Folklore - 2013 (RR-8405)
(BIN) Branch Prediction with Neural Networks - Hidden layers and Recurrent Connections
(BIN) Brief Calculus - Benjamin Crowell - Nov 10th, 2015
(BIN) Bringing SIMD-128 to JavaScript (TC-39)
(BIN) Broadword Implementation of Parenthesis Queries
(BIN) Broadword Implementation of Rank-Select Queries (Nov 19, 2014)
(BIN) Brook for GPUs - Stream Computing on Graphics Hardware - Paper
(BIN) Brook for GPUs - Stream Computing on Graphics Hardware - Slides (2004)
(BIN) B-trees, Shadowing, and Clones (2007)
(BIN) Bugs as Deviant Behavior - A General Approach to Inferring Errors in Systems Code - ACM - 2001 (deviant-sosp-01)
(BIN) Building a Bw-Tree Takes More Than Just Buzz Words - 2018 (mod342-wangA)
(BIN) Building R Packages - An Introduction
(BIN) Build Systems a la Carte - 2018 (build-systems-5ab0f42d0f937)
(BIN) Bumper Sticker Computer Science
(BIN) Burrows-Wheeler Transform and FM Index - Slides (Ben Langmead, Johns Hopkins)
(BIN) Bypass Control Flow Guard Comprehensively - Slides (2015)
(BIN) C++14 - Working Draft (N3797)
(BIN) C++17 Language Features Reference Card (2019)
(BIN) C++20 Reference Card - 29th Jan 2020
(BIN) Cache and IO Efficient Algorithms
(BIN) Cache Aware Bi-tier Task-stealing in Multi-socket Multi-core Architecture (icpp11)
(BIN) Cache-Aware Lock-Free Queues for Multiple Producers-Consumers and Weak Memory Consistency 1
(BIN) Cache-Aware Lock-Free Queues for Multiple Producers-Consumers and Weak Memory Consistency
(BIN) Cache, Hash and Space-Efficient Bloom Filters (10.1.1.93.7688)
(BIN) Cache, Hash and Space-Efficient Bloom Filters
(BIN) Cache-Oblivious Algorithms and Data Structures (Demaine, 2002)
(BIN) Cache-Oblivious Peeling of Random Hypergraphs - 2nd Dec 2013 (1312.0526)
(BIN) Cache-Oblivious Streaming B-trees
(BIN) Cache Organization and Memory Management of the Intel Nehalem Computer Architecture
(BIN) CAF - The C++ Actor Framework for Scalable and Resource-efficient Applications - ACM 2014 (ageresplash2014_submission_5)
(BIN) Calculus Made Easy
(BIN) Calculus Refresher, Version 2008.4 (Paul Garrett)
(BIN) Canopy - An End-to-End Performance Tracing and Analysis System - 2017 (sosp17-final14)
(BIN) Can't Get To Performing Without Storming (pat-ma03)
(BIN) Captain Hook - Pirating AVs to Bypass Exploit Mitigations - Slides (2016)
(BIN) CASEVision - ClearCase Administration Guide (007-1774-020)
(BIN) C Cheat Sheet (ashlyn-black_c-reference)
(BIN) Checking System Rules Using System-Specific, Programmer-Written Compiler Extensions (mc-osdi)
(BIN) Chihuahua - A Concurrent, Moving, Garbage Collector using Transactional Memory - 2015 (anderson-transact-2015)
(BIN) Chinese Remainder Theorem and its Applications
(BIN) Choosing a Good Chart (A. Abela, 2006)
(BIN) Chord - A Scalable Peer-to-peer Lookup Service for Internet Applications (2001)
(BIN) CityHash - Fast Hash Functions for Strings - Slides (121017-slides)
(BIN) CK-12 Probability and Statistics Advanced - Second Edition
(BIN) ClearCase Administrator's Guide (7165_2167_cc_proj.admin)
(BIN) Cluster-based Mixed Coding Schemes for Inverted File Index Compression (v6i10a4)
(BIN) Codes for Positive Integers - CS423, Lecture 6, McGill (2008)
(BIN) Cognitive Biases Potentially Affecting Judgment of Global Risks (2008)
(BIN) Colfax Optimization Techniques for the Intel MIC Architecture - Part 1 of 3 - Multi-threading and Parallel Reduction (2015)
(BIN) Colfax Optimization Techniques for the Intel MIC Architecture - Part 2 of 3 - Strip-Mining for Vectorization (2015)
(BIN) Colfax Optimization Techniques for the Intel MIC Architecture - Part 3 of 3 - False Sharing and Padding (2015)
(BIN) Colfax - Programming and Optimization for Intel Architecture (2016)
(BIN) Comdb2 - Bloomberg's Highly Available Relational Database System - 2017 (p1377-scotti)
(BIN) Communication Efficient Distributed Machine Learning with the Parameter Server
(BIN) Comparative Performance of Memory Reclamation Strategies for Lock-Free and Concurrently-Readable Data Structures
(BIN) Competitive Programmer's Handbook - Antti Laaksonen - (10th December, 2017)
(BIN) Compiler Calling Conventions
(BIN) Compiler Confidential - Eric Brumer (6th Sept 2013)
(BIN) Compiler Construction - Niklaus Wirth - 1996 (CBEAll)
(BIN) Compiler Construction - Niklaus Wirth - 2005 (CBEAll)
(BIN) Compiler Construction - The Art of Niklaus Wirth (2000)
(BIN) Compiler Design In C
(BIN) Compiler Design - Theory, Tools and Examples
(BIN) Compiler Internals - Exceptions and RTTI - Igor Skorchinsky (Hex-Rays) - Recon 2012
(BIN) Compiling Python Modules to Native Parallel Modules Using Pythran and OpenMP Annotations
(BIN) Component Object Model - An Overview and Practical Implementation (IJSARTV3I38438636248891114924768)
(BIN) Compressed Bloom Filters
(BIN) Compressed Inverted Indexes - Slides (2010)
(BIN) Compressed Perfect Embedded Skip Lists for Quick Inverted-Index Lookups
(BIN) Compression - Slides
(BIN) Computer Systems Research
(BIN) Concurrent Hash Tables - Fast and General - 2016 (1601.04017v2)
(BIN) Concurrent Hash Tables - Fast and General - ACM - 2019 (3309206)
(BIN) Concurrent Programming for Scalable Web Architectures - Benjamin Erb - Thesis (April 2012) (vts_8082_11772)
(BIN) Concurrent Reference Counting and Resource Management in Constant Time - 29 Feb 2020 (2002.07053)
(BIN) Conflict-Free Vectorization of Associative Irregular Applications with Recent SIMD Architectural Advances - Feb 2018 (cgo18)
(BIN) Consistently Faster and Smaller Compressed Bitmaps with Roaring - 19th April, 2016 (1603.06549)
(BIN) Constraint Propagation Algorithms for Temporal Reasoning - A Revised Report (vilain-kautz-book)
(BIN) Convex Optimization (2009)
(BIN) Convex Optimization - Slides
(BIN) Cooperative Kernels - GPU Multitasking for Blocking Algorithms (fse2017)
(BIN) Coq - The World's Best Macro Assembler
(BIN) Cores of Random r-Partite Hypergraphs - Dec 15 2010 (tr001_10)
(BIN) CORFU - A Shared Log Design for Flash Clusters
(BIN) COZ - Finding Code that Counts with Causal Profiling - 2015 (090-curtsinger)
(BIN) COZ - Finding Code that Counts with Causal Profiling - 2015 (UM-CS-2015-008)
(BIN) COZ - Finding Code that Counts with Causal Profiling - Slides (2015)
(BIN) CPU Caches - Slides (2017)
(BIN) Creating R Packages - A Tutorial (Sept 14 2009)
(BIN) Critique of Microkernel Architectures (Slides)
(BIN) CS195V Brown - Week 10 - CUDA Part 1 - Slides
(BIN) CS195V Brown - Week 11 - CUDA Part 2 - Slides
(BIN) CS195V Brown - Week 1 - Advanced GPU Programming (Intro)
(BIN) CS195V Brown - Week 2 - Modern OpenGL - Slides
(BIN) CS195V Brown - Week 3 - GLSL Programming - Slides
(BIN) CS195V Brown - Week 4 - Noise Functions - Slides
(BIN) CS195V Brown - Week 6 - Image Samplers and Atomic Operations - Slides
(BIN) CS195V Brown - Week 7 - Fluids - Slides
(BIN) CS195V Brown - Week 8 - Materials and BRDFs - Slides
(BIN) CS195V Brown - Week 9 - GPU Architecture and Other Shading Languages - Slides
(BIN) C++ Standard - 2012-01-16 - Working Draft (N3337)
(BIN) Cuckoo Filter - Practically Better Than Bloom
(BIN) Cuckoo++ Hash Tables - High-Performance Hash Tables for Networking Applications - 2017 (1712.09624)
(BIN) CUDA Asynchronous Memory Usage and Execution (cuda_05_ykhung)
(BIN) CUDA C and C++ Streams and Concurrency - NVIDIA - Slides
(BIN) CUDA C Programming Guide v8.0 - Design Guide - September, 2016 (PG-02829-001_v8.0)
(BIN) CUDA Debugging with Command Line Tools - 2014 (S4578)
(BIN) CUDA Managed Memory - Slides (2020)
(BIN) CUDA Optimizations - Slides (April 2016)
(BIN) CUDA_practice
(BIN) CUDA - Quick Reference
(BIN) CUDAsmith - A Fuzzer for CUDA Compilers (TR-2020-05)
(BIN) CUDA Streams - Best Practices and Common Pitfalls - Slides (2012)
(BIN) CUDA Thread Basics - Slides (2011)
(BIN) CUDA Thread-Indexing Cheatsheet
(BIN) CUDA Threads - GPU Architecture and Programming - NYU CSCI-GA.3033-012 (2012)
(BIN) CUDA Unified Memory - GPGPU - Slides (2015)
(BIN) Curves and Surfaces - Lecture Notes for Geometry 1 - Henrik Schlichtkrull - University of Copenhagen (2011)
(BIN) Dapper - A Large-Scale Distributed Systems Tracing Infrastructure (36356)
(BIN) Database Fundamentals
(BIN) Database System Implementation - COSC 404 - Slides
(BIN) Data Compression Techniques - Lecture 1 - Shannon's Theorem - University of Helsinky - Slides (2015)
(BIN) Data Compression Techniques - Lecture 2 - Morse Code to Huffman Coding - University of Helsinky - Slides (2015)
(BIN) Data Compression Techniques - Lecture 3 - Integer Codes 1 - University of Helsinky - Slides (DCT2015-Lecture3Web)
(BIN) Data Compression Techniques - Lecture 4 - Integer Codes 2 - University of Helsinky - Slides (DCT2015-Lecture4)
(BIN) Data Compression Techniques - Lecture 5 - Adaptive Prefix-Free Coding - University of Helsinky - Slides (2015)
(BIN) Data Compression Techniques - Lecture 6 - Arithmetic Coding (2015)
(BIN) Data Compression Techniques - Lecture 7 - Dictionary Compression (DCT2015-Lecture7Web)
(BIN) DataMining-ch1
(BIN) DataMining-ch2
(BIN) DataMining-ch3
(BIN) DataMining-ch4
(BIN) DataMining-ch5
(BIN) DataMining-ch6
(BIN) DataMining-ch7
(BIN) Data-Parallel Hashing Techniques for GPU Architectures - 11 Jul 2018 (1807.04345)
(BIN) Data Structures and Algorithms (2008)
(BIN) Data Structures for Text Sequences
(BIN) Data Transfer Matters for GPU Computing - 2013 (icpads13)
(BIN) Debugging Programs that use Atomic Blocks and Transactional Memory (2010)
(BIN) Debugging Tools for Windows (b7f35e165e8b2083ad68d4dbd398b7ba)
(BIN) Debugging Tools for Windows (WinDbg, KD, CDB, NTSD)
(BIN) Debunking the 100x GPU vs CPU Myth - An Evaluation of Throughput Computing on CPU and GPU
(BIN) DEC - The Mistakes That Led To Its Downfall (Goodwin Paper)
(BIN) DEC - The Mistakes that led to its Downfall
(BIN) Deep Learning Tutorial - Slides - 2013 (lecun-ranzato-icml2013)
(BIN) DeepState - Symbolic Unit Testing for C and C++ - 2018 (bar18)
(BIN) Demystifying DAS, SAN, NAS, NAS Gateways, Fibre Channel, and iSCSI
(BIN) Demystifying GPU Microarchitecture through Microbenchmarking - 2010 (gpuarch-ispass2010)
(BIN) Deny Capabilities for Safe, Fast Actors - Ponylang (2015)
(BIN) Depth-First Search and Linear Graph Algorithms - Tarjan (1972)
(BIN) Derivability, Consistency (rj599)
(BIN) Derivability, Redundancy and Consistency of Relations Stored in Large Data Banks - E. F. Codd (1969)
(BIN) Designing COM Interfaces - 1995
(BIN) Deterministic Dynamic Deadlock Detection and Recovery
(BIN) Detours - Binary Interception of Win32 Functions - 1999 (huntusenixnt99)
(BIN) Developing and Porting Applications to AIX (sg245674)
(BIN) Digital FX32 - Running 32-bit x86 Applications on Alpha NT
(BIN) Dijkstra's in Disguise - Eric Jang (12th August, 2018)
(BIN) DI-MMAP - A High Performance Memory Map Runtime for Data-Intensive Applications (Nov 16 2012) - Deck
(BIN) DI-MMAP - A High Performance Memory Map Runtime for Data-Intensive Applications (Nov 16 2012) - Paper
(BIN) Direct Cache Access for High Bandwidth Network IO - 2005 (huggahalli05)
(BIN) Disk Based Hash Tables and Quantified Numbers (24th March, 2014)
(BIN) Disruptor - High performance alternative to bounded queues for exchanging data between concurrent threads (May 2011)
(BIN) Dissecting the NVIDIA Turing T4 GPU via Microbenchmarking - 18 Mar 2019 (1903.07486)
(BIN) Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking - 2018 (1804.06826)
(BIN) Dissecting the NVIDIA Volta GPU Architecture via Microbenchmarking - 2018 - Slides (1804.06826)
(BIN) Distributed and Parallel Time Series Feature Extraction for Industrial Big Data Applications - 25th October 2016 (1610.07717v1)
(BIN) Distributed Component Object Model (DCOM) Remote Protocol - MS-DCOM-2015 (October 16th, 2015)
(BIN) Dodd-Frank Act Stress Test 2014 - Supervisory Stress Test Methodology and Results - March 2014 (bcreg20140320a1)
(BIN) Down For The Count - Getting Reference Counting Back in the Ring (rc-ismm-2012)
(BIN) Draw Me A Local Kernel Debuger - Slides (2015)
(BIN) Dropout - A Simple Way to Prevent Neural Networks from Overfitting - 2014 (JMLRdropout)
(BIN) DTrace Dynamic Tracing In Oracle Solaris, Mac OS X & FreeBSD
(BIN) Dueling UNIXes and the UNIX Wars (login_apr15_17_salus).pdf
(BIN) Dynamic Storage Allocation - A Survey and Critical Review
(BIN) Dynamic Storage Allocation - Survey and Critical Review
(BIN) Effective Computation of Biased Quantiles over Data Streams (bquant)
(BIN) Efficient Algorithms for Large-Scale Image Analysis (978-3-86644-786-8_PDFA)
(BIN) Efficient Computation of Binomial Coefficients Using Splay Trees - 2016 (10.11648.j.ijdst.20160201.14)
(BIN) Efficient Estimation of Mutual Information for Strongly Dependent Variables (gao15)
(BIN) Efficient Estimation of Word Representations in Vector Space - 2013 (1301.3781)
(BIN) Efficient Estimation of Word Representations in Vector Space - 7th Sep 2013 (1301.3781)
(BIN) Efficient Exploitation of Parallelism on Pentium III and Pentium 4 Processor-Based Systems - 2001 (art_6)
(BIN) Efficient Hashing with Lookups in two Memory Accesses - 2018 (0407023v1)
(BIN) Efficient Hash Probes on Modern Processors (icde2007)
(BIN) Efficient Implementation of Lazy Suffix Trees (gie-kur-sto-2003)
(BIN) Efficient Implementation of Reductions on GPU Architectures (2017)
(BIN) Efficient Implementation of Sorting on Multicore SIMD CPU Architecture - Slides - VLDB 2008 (9-29-15)
(BIN) Efficient Implementation of Sorting on Multicore SIMD CPU Architecture - VLDB 2008 (1454171)
(BIN) Efficient Lightweight Compression Algorithm Alongside Fast Scans (damon15)
(BIN) Efficient Lossless Compression of Trees and Graphs
(BIN) Efficiently Compiling Efficient Query Plans for Modern Hardware - 2011 (p539-neumann)
(BIN) Efficient Parallel Graph Exploration on Multi-Core CPU and GPU - 2011 (pact11-hong)
(BIN) Efficient String Matching - An Aid to Bibliographic Search - Aho-Corasick (1975)
(BIN) Efficient Virtual Memory for Big Memory Servers (isca13_direct_segment)
(BIN) Egocentrism Over E-Mail - Can We Communicate as Well as We Think (krugeretal05)
(BIN) EIT - The Internal Extent Formula for Compacted Tries
(BIN) Elementary Calculus - An Infinitesimal Approach (keislercalc-03-07-17)
(BIN) Elevated - Function 2009
(BIN) ELF Format
(BIN) ELF Handling for Thread-Local Storage - Ulrich Drepper (2005)
(BIN) Eliminating Global Interpreter Locks in Ruby through Hardware Transactional Memory (PPoPP2014_RubyGILHTM)
(BIN) Empirical Study of the Anatomy of Modern SAT Solvers (2010)
(BIN) Encyclopedia of Controller Fundamentals and Features - Firmware Version 3.2 to 8.0 (8_0_775041-01C)
(BIN) Engineering Better Software at Microsoft - Jason Yang, Slides - 30th Nov 2011 (25-sal)
(BIN) Enhancing Server Availability and Security Through Failure-Oblivious Computing - 2004 (rinard)
(BIN) ESET - A Machine-Learning Method to Explore the UEFI Landscape (Sept 2019)
(BIN) Establishing a Base of Trust with Performance Counters for Enterprise Workloads - 2015 (atc15-paper-nowak)
(BIN) Estimating Flight Characteristics of Anomalous Unidentified Aerial Vehicles (entropy-21-00939-v2)
(BIN) Estoteric Hooks - Alex Ionescu - Slides (2015)
(BIN) Evaluation of Contemporary Graph Databases for Efficient Persistence of Large-Scale Models
(BIN) Evaluation of Parallel Design Patterns for Message Processing Systems on Embedded Multicore Systems
(BIN) Evaluation of Rolling Sphere Method Using Leader Potential Concept - A Case Study - 2006 (IT P501-124)
(BIN) EventSource Activities Specification (2016)
(BIN) Event Source User Guide
(BIN) Everything We Know About CRC But Afraid To Forget (3rd September, 2010)
(BIN) Everything You Always Wanted to Know About Synchronization but Were Afraid to Ask (p33-david)
(BIN) Exact Minimum Degree Thresholds for Perfect Matchings in Uniform Hypergraphs (2012)
(BIN) Experiences in the Land of Virtual Abstractions - Slides - 2014 (VEE14-present601)
(BIN) Experiences Porting Real Time Signal Processing Pipeline CUDA Kernels to Kepler and Windows 8 - Slides - 2014 (S4148-rt-signal-processing-pipeline-cuda-kernels-kepler-win8)
(BIN) Expert programmers have fine-tuned cortical representations of source code (2020.01.28.923953v1.full)
(BIN) Explaining AdaBoost
(BIN) eXplode- A Lightweight, General System for Finding Serious Storage System Errors (explode-osdi06)
(BIN) Exploiting Coarse-Grain Speculative Parallelism
(BIN) Exploiting Deferred Destruction - An Analysis of Read-Copy-Update Techniques in Operating System Kernels (RCUdissertation.2004.07.14e1)
(BIN) Exploiting SIMD for Complex Numerical Predicates - 2015 (HardBD16_3)
(BIN) Exploring Control Flow Guard in Windows 10 - Trend Micro
(BIN) Exploring PLSQL New Features Best Practices - OOW 2013 Aharonovich
(BIN) Exponential Golomb and Rice Error Correction Codes for Generalized Near-Capacity Joint Source and Channel Coding (ExpgECRiceEC)
(BIN) Extending Oracle E-Business Suite Release 12.1 and above using Oracle Application Express (345780)
(BIN) Extending Python for High-performance Data-Parallel Programming (March 24, 2014)
(BIN) External Perfect Hashing for Very Large Key Sets - 2007 (cikm07)
(BIN) Extra 300 - Pilot's Operating Handbook (20th Sept, 2009)
(BIN) Faliure-Atomic msync() - A Simple and Efficient Mechanism for Preserving the Integrity of Durable Data
(BIN) Fallout - Reading Kernel Writes From User Space - 29th May 2019 (1905.12701)
(BIN) Fast and Scalable Minimal Perfect Hashing for Massive Key Sets - 2017 (1702.03154)
(BIN) Fast and Space Efficient Trie Searches - Phil Bagwell - ACM
(BIN) FastBDT - A speed-optimized and cache-friendly implementation of stochastic gradient-boosted decision trees for multivariate classification - 2016 (1609.06119v1)
(BIN) Fast Bit Compression and Expansion with Parallel Extract and Parallel Deposit Instructions - 2006 (hilewitz06)
(BIN) Fast Bit Gather, Bit Scatter and Bit Permutation Instructions for Commodity Microprocessors - 2008 (Hilewitz_JSPS_08)
(BIN) Fast CRC Computation for Generic Polynomials Using PCLMULQDQ Instruction - Intel (December, 2009)
(BIN) Fast Databases with Fast Durability and Recovery Through Multicore Parallelism (osdi14-paper-zheng_wenting)
(BIN) Fast Deterministic Selection - Andrei Alexandrescu - June 2016 (1606.00484v1)
(BIN) Faster 64-bit Universal Hashing using Carry-less Multiplication - 2015 (1503.03465)
(BIN) Faster Base64 Encoding and Decoding Using AVX2 Instructions v4 (2018) (1704.00605)
(BIN) Faster Population Counts using AVX2 Instructions (1611.07612v1)
(BIN) Fast Exact Multiplication by the Hessian - 1993 (nc-hessian)
(BIN) FAST - Fast Architecture Sensitive Tree Search on Modern CPUs and GPUs
(BIN) FAST - Fast Architecture Sensitive Tree Search on Modern CPUs and GPUs - Slides
(BIN) Fast Keyed Hash and Pseudo-Random Function using SIMD Multiply and Permute - 20 Nov 2016 (1612.06257v2)
(BIN) Fast Multiple String Matching Using Streaming SIMD Extensions Technology - 2013 (psc13p08_presentation)
(BIN) Fast Packed String Matching for Short Patterns - 2012 (1209.6449)
(BIN) Fast Parallel GPU-Sorting Using a Hybrid Sort
(BIN) Fast Parallel Suffix Array on the GPU
(BIN) Fast Prefix Search in Little Space, with Applications
(BIN) Fast Quicksort Implementation Using AVX Instructions - 2015 (10.1.1.1009.7773)
(BIN) Fast Scalable Construction of (Minimal Perfect Hash) Functions - 22 Mar 2016, v2 (1603.04330)
(BIN) Fast Scalable Construction of (Minimal Perfect Hash) Functions
(BIN) Fast Search in Hamming Space with Multi-Index Hashing
(BIN) Fast Sorted-Set Intersection using SIMD Instructions (p1-SCHLEGEL)
(BIN) Fast Sorting Algorithms using AVX-512 on Intel Knight's Landing (1704.08579)
(BIN) Fast Sorting Algorithms using AVX-512 on Intel Knights Landing - 24 Apr 2017 (1704.08579)
(BIN) Fast Sort on CPUs, GPUs and Intel MIC Architectures - Technical Report - Intel Labs (intel-labs-radix-sort-mic-report)
(BIN) Fast Splittable Pseudorandom Number Generators (oopsla14)
(BIN) Fast String Correction with Levenshtein-Automata (2002) (10.1.1.16.652)
(BIN) Featherweight Threads for Communication - 2011 (parasites_tech11)
(BIN) FERRARI - Flexible and Efficient Reachability Range Assignment for Graph Indexing
(BIN) Fibers Under The Magnifying Glass - 2018 (p1364r0)
(BIN) Fibre Channel Fundamentals
(BIN) Fibre Channel Reference Card
(BIN) Filter Manager - Windows
(BIN) Finance - Salomon Smith Barney Introductory Guide to Equity Options (1998)
(BIN) Finding Frequent Items in Data Streams
(BIN) Finding Frequent Items in Data Streams - PLVDB - 2008
(BIN) Finding Minimal Perfect Hash Functions - 1986 (10.1.1.144.9650)
(BIN) Finding Similar Items
(BIN) Finding Small Balanced Separators (2006)
(BIN) FLASHRELATE - Extracting Relational Data from Semi-Structured Spreadsheets Using Examples (Microsoft Research - April 2014)
(BIN) Flush+Reload - A High-Resolution, Low-Noise, L3 Cache Side-Channel Attack (2014)
(BIN) Folding and Unfolding - Erik D. Demaine - Ph.D Thesis 2001 (eddemaine2001)
(BIN) Foreign Library Interface
(BIN) Foundations of Databases
(BIN) Foundations of Data Science (June, 2016)
(BIN) Foundations of Data Science
(BIN) FPGA Acceleration by Dynamically-Loaded Hardware Libraries - 2016 (tr16_03_Nannarelli_A)
(BIN) Fractal Prefetching B+ Trees - Optimizing Both Cache and Disk Performance
(BIN) Framework for Instruction-level Tracing and Analysis of Program Executions (2006)
(BIN) Free Launch - Optimizing GPU Dynamic Kernel Launches through Thread Reuse (2015)
(BIN) From Numerical Cosmology to Efficient Bit Abstractions for the Standard Library - Vincent Reverdy - CppCon 2016
(BIN) Fully Concurrent Garbage Collection of Actors on Many-Core Machines - 2013 (opsla237-clebsch)
(BIN) Fundamentals of Calculs - Crowell et al - 2016
(BIN) Fundamentals of COM(+) - Part 1 - Slides - Don Box
(BIN) Fundamentals of Deep Learning of Representations - 2014 (Tel-Aviv-7nov2014)
(BIN) Fundamentals of Learning (2015)
(BIN) Further Scramblings of Marsaglia's Xorshift Generators - 23 May 2016 (1404.0390)
(BIN) Futexes Are Tricky - Ulrich Drepper (2011)
(BIN) General Analysis of Maxima and Minima in Constrained Optimization Problems
(BIN) General Incremental Sliding-Window Aggregation (p702-tangwongsan)
(BIN) Generalized Golomb Codes and Adaptive Coding of Wavelet-Transformed Image Subbands (August 15th, 2003)
(BIN) Generalized Histogram Algorithms for CUDA GPUs - Slides - 2012 (histogram_para2012)
(BIN) Generating Sequences With Recurrent Neural Networks (1308.0850v5)
(BIN) Generating Text with Recurrent Neural Networks (LANG-RNN)
(BIN) Getting Physical - Extreme Abuse of Intel-based Paging Systems - Slides - 2016 (CSW2016_Economou-Nissim_GettingPhysical)
(BIN) Getting Started with CUDA (2008)
(BIN) Getting Started with Software Tracing in Windows Drivers (WinHEC 2005 - April 18, 2005)
(BIN) Git from the Bottom Up
(BIN) Git Magic
(BIN) Go 1.5 Concurrent Garbage Collector Pacing
(BIN) Goals Gone Wild - The Systematic Side Effects of Over-Prescribing Goal Setting - Harvard Business School (09-083)
(BIN) Google's Neural Machine Translation System - Bridging the Gap between Human and Machine Translation - 2016 (1609.08144v1)
(BIN) GPERF - A Perfect Hash Function Generator
(BIN) GPU-ArraySort - A parallel, in-place algorithm for sorting large number of arrays (2016)
(BIN) GPU Control Flow and Synchronization - Slides
(BIN) GPU Optimization Fundamentals
(BIN) GPU Programming Basics - Slides
(BIN) GPU Random Numbers via the Tiny Encryption Algorithm (2010)
(BIN) Grand Central Dispatch - FreeBSD Dev Summit (18 Sep 2009)
(BIN) GraphBLAS Mathmatics - Provisional Release 1.0 - Jeremy Kepner (26th April, 2017)
(BIN) Graphs, Hypergraphs and Hashing (1994)
(BIN) Graph Theoretic Obstacles to Perfect Hashing - 1994 (TR0257)
(BIN) Graph Theory (2005)
(BIN) GRIM - Leveraging GPUs for Kernel Integrity Monitoring
(BIN) GTC 2017 - Parallel Depth First on GPU - Slides (s7469-maxim-naumov-parallel-depth-first-on-gpu)
(BIN) Guide to Automatic Vectorization with Intel AVX-512 Instructions in Knights Landing Processors - Bonan Zhang - Colfax International, 2016 (Colfax_KNL_AVX512_Guide)
(BIN) Gunrock - A Fast and Programmable Multi-GPU Graph Processing Library - Slides - 2015 (SC5139)
(BIN) Gunrock - A Fast and Programmable Multi-GPU Graph Processing Library - Slides - 2016 (S6374)
(BIN) Gunrock - A High-Performance Graph Processing Library on the GPU - 2016
(BIN) H2O - The Opytimized HTTP Server (Kazuho Oku, 2014)
(BIN) Hardware Acceleration for Memory-to-Memory Copies - January 13, 2017 (EECS-2017-2)
(BIN) Hardware-Aware Optimization- Using Intel Streaming SIMD Extensions - Slides (2010)
(BIN) Hardware Breakpoint (or watchpoint) usage in Linux Kernel (ols2009-pages-149-158)
(BIN) Hardware is the new software (baumann-hotos17)
(BIN) Hardware Transactional Memory on Haswell
(BIN) HARE - Hardware Acceleration for Regular Expressions - 2016 (micro16)
(BIN) Harnessing Intel Processor Trace on Windows for Vulnerability Discovery - D1T1 - Richard Johnson - Slides (2017)
(BIN) Hash and Displace - Efficient Evaluation of Minimum Perfect Hash Functions - 1999 (10.1.1.148.7694)
(BIN) Hashcash - A Denial of Service Counter-Measure (1st August, 2002)
(BIN) Hash, Displace, and Compress (esa09)
(BIN) Hash Functions for GPU Rendering - 2020 (Jarzynski2020Hash)
(BIN) HASHI - An Application-Specific Instruction Set Extension for Hashing - 2014 (adms14_arnold)
(BIN) Hash Tables - Jeff Erickson (2014)
(BIN) Haskell vs. F sharp vs. Scala - A High-Level Language Features and Parallelism Support Comparison (fhpc12)
(BIN) Haswell Block Diagram
(BIN) HAT-trie - A Cache-conscious Trie-based Data Structure for Strings - 2007 (CRPITV62Askitis)
(BIN) HDF5 - Taming Parallel IO Complexity with Auto-Tuning (P4091-0713_2)
(BIN) Heapy - A Memory Profiler and Debugger for Python - 2006 (heapy-thesis)
(BIN) HELIX-RC - An Architecture-Compiler Co-Design for Automatic Parallelization of Irregular Programs (campanoni14-isca)
(BIN) Heracles- Improving Resource Efficiency at Scale (2015.heracles.isca)
(BIN) Heracles - Improving Resource Efficiency at Scale (2015)
(BIN) HexRaysCodeXplorer - Making Object-Oriented RE Easier - Slides (2013)
(BIN) HexRaysCodeXplorer - Making Object-Oriented RE Easier - Slides (2014)
(BIN) Hidden Markov Model
(BIN) High-performance Concurrency Control Mechanisms for Main-memory Databases (p298_per-akelarson_vldb2012)
(BIN) High Performance Histograms on SIMT and SIMD Architectures - M.E.R. Berger, Master's Thesis (2015)
(BIN) High Performance IO with NUMA Systems in Linux
(BIN) High Speed Hashing for Integers and Strings - 2020 (1504.06804)
(BIN) High Throughput Heavy Hitter Aggregation for Modern SIMD Processors (damon13)
(BIN) Histograms - CUDA Handbook - Slides (2015)
(BIN) Hoard - A Scalable Memory Allocator for Multithreaded Applications (berger-asplos2000)
(BIN) How Does a GPU Shader Work (2018)
(BIN) How fast can we make interpreted Python - NYU (2012)
(BIN) How Microsoft Builds Software (1997)
(BIN) How Not To Measure Latency - Gil Tene - LL Summit NYC (12-Nov-2013)
(BIN) How the VAX Lost Its POLY (and EMOD and ACB_floating too) (vax_poly)
(BIN) How to Benchmark Code Execution Times on Intel IA-32 and IA-64 Instruction Set Architectures - September, 2010 (324264-001)
(BIN) How To Code In HTML5 And CSS3 - Damian Wielgosik
(BIN) How TokuDB Fractal Tree Databases Work Presentation
(BIN) How To Overcome the GIL Limitations (While Staying In Python Ecosphere) - Francesc Alted (2011)
(BIN) How to Partition a Billion-Node Graph - Microsoft Research (2016)
(BIN) How to Read a Paper (Feb 17th 2016)
(BIN) How to Test 10G Ethernet - WhitePaper - Spirent (March, 2012)
(BIN) How to use Event Tracing for Windows for Performance Analysis
(BIN) How to Write Fast Code - SIMD Vectorization - CMU - 2008 - Slides (slides-18-645-simd)
(BIN) How To Write Fast Numerical Code - Slides (2011)
(BIN) How To Write Shared Libraries - v4.1.2 (Drepper, 2001)
(BIN) HTTP as the Narrow Waist of the Future Internet
(BIN) Huffman Coding - Slides (2012)
(BIN) HyperANF - Approximating the Neighbourhood Function of Very Large Graphs on a Budget (2011)
(BIN) Hyperedge Replacement Graph Grammars
(BIN) Hypergraph Algorithms and Applications - CS6824 - Slides (January 22, 2014)
(BIN) Hypergraph-Based Anomaly Detection in Very Large Networks - 2007 (silva_willett_tpami07)
(BIN) Hypergraphs - Algorithms, Implementations, and Applications - Poster (2015)
(BIN) HyperLogLog - The Analysis of a Near-Optimal Cardinality Estimation Algorithm (914-3045-2-PB)
(BIN) Hyperparameter Optimization using Hyperopt - Slides (2016)
(BIN) iBFS - Concurrent Breadth-First Search on GPUs - 2016 (ibfs_tcm18-284417)
(BIN) IBM DB2 for i - Indexing Methods and Strategies
(BIN) IBM Fibre Channel Basic Storage Area Network (SAN) Configuration Setup Guide
(BIN) IDA Plug-in Writing in C-C++ - Version 1.1 - Steve Micallef (2009)
(BIN) Ideal Hash Trees - Phil Bagwell - ACM
(BIN) IDF 2012 NVM Express and the PCI Express SSD Revolution
(BIN) IEEE 802.3ad Link Aggregation
(BIN) I Got 99 Problems But a Kernel Pointer Ain't One - Recon 2013 - Slides - Alex Ionescu
(BIN) Image and Video Processing - Binary Encoding and Quantization (2016)
(BIN) IMP - Indirect Memory Prefetcher - MIT (2015)
(BIN) Implementing Algebraic Effects in C, or, Monads for Free in C - 2017 (algeff-in-c-tr-v2)
(BIN) Implementing Sorting in Databases (2006)
(BIN) Improved Bounds For Covering Complete Uniform Hypergraphs - (April 3rd, 2007)
(BIN) Improved Fast Similarity Search in Dictionaries - 2010 (1008.1191v2)
(BIN) Improvement of Fitch function for Maximum Parsimony in Phylogenetic Reconstruction with Intel AVX2 Assembler Instructions - 24 June 2013 (TR20130624-1)
(BIN) Improving Automated Analysis of Windows x64 Binaries - Uninformed v4a1 (April 2006)
(BIN) Improving Compiler Optimization with Machine Learning (2014_Kulkarni_Sameer_PhD)
(BIN) Improving Python's Memory Allocator - Evan Jones (2005)
(BIN) Improving Real-Time Performance with CUDA Persistent Threads (CuPer) on the Jetson TX2 - Concurrent Real-Time White Paper (2016)
(BIN) Improving the speed of neural networks on CPUs (37631)
(BIN) Incremental Construction of Minimal Acyclic Finite State Automata and Transducers
(BIN) Index Compression - Slides (2011)
(BIN) Index Compression - Slides
(BIN) Index Internals - Rebuilding the Truth
(BIN) Index Search Algorithms for Databases and Modern CPUs - Florian Gloss (Nov 2010)
(BIN) Induced subgraphs of hypercubes and a proof of the Sensitivity Conjecture (2019)
(BIN) Infinite-Alphabet Prefix Codes Optimal for Beta-Exponential Penalties (10.1.1.560.4484)
(BIN) Information Retrieval - Compression, Encoding - Slides - Cornell (2013)
(BIN) Information Theory for Intelligent People (2018)
(BIN) Initial End-to-End Performance Evaluation of 10-Gigabit Ethernet - 2003 (hoti03)
(BIN) InK-Compact- In-Kernel Stream Compaction and Its Application to Multi-Kernel Data Visualization on General-Purpose GPUs - 2013
(BIN) Inline Function Expansion for Compiling C Programs - 1989 (p246-chang)
(BIN) In-memory Columnar Store for PostgreSQL (322_IMCS)
(BIN) Inside IOCP
(BIN) Inside The Deal That Made Bill Gates 350,000,000 (1986)
(BIN) Inside the Python GIL - Dave Beazley (2009)
(BIN) Instant Loading for Main Memory Databases - 2013 (p1702-muehlbauer)
(BIN) Instant Loading for Main Memory Databases - VLDB - 2013, Vol 6, No 14 (p1702-muehlbauer)
(BIN) Integer Encoding - Chapter 9 (2013)
(BIN) Intel 5th Generation Processor Family - Specification Update - Revision 029 - July 2017 (330836-029)
(BIN) Intel 64 and IA-32 Architectures Optimization Reference Manual - April 2018 (248966-040)
(BIN) Intel 64 and IA-32 Architectures Optimization Reference Manual - April 2019 (248966-041)
(BIN) Intel 64 and IA-32 Architectures Optimization Reference Manual - December 2017 (248966-039)
(BIN) Intel 64 and IA-32 Architectures Optimization Reference Manual - June 2016 (248966-033)
(BIN) Intel 64 and IA-32 Architectures Optimization Reference Manual - May 2020 (248966-043)
(BIN) Intel 64 and IA-32 Architectures Optimization Reference Manual - Sept 2014 (248966-030)
(BIN) Intel 64 and IA-32 Architectures Performance Monitoring Events - Revision 1.0 - December 2017 (335279-001)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Combined Volumes 1-3 - June 2016 (325462-059US)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Combined Volumes 1-3 - Sept 2014 (325462-052US)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Combined Volumes 1-4 - December 2017 (325462-sdm-vol-1-2abcd-3abcd)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Combined Volumes 1-4 - May 2018 (325462-sdm-vol-1-2abcd-3abcd)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Combined Volumes 1-4 - May 2019 (325462-sdm-vol-1-2abcd-3abcd)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Combined Volumes 1-4 - October 2019 (325462-071US-sdm-vol-1-2abcd-3abcd)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Documentation Changes - June 2016 (252046-051)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Documentation Changes - May 2019 (252046-062)
(BIN) Intel 64 and IA-32 Architectures Software Developer’s Manual V3 - Sept 2014 (325384-052US)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Volume 2A - Instruction Set Reference, A-L - June 2016 (253666-059US)
(BIN) Intel 64 and IA-32 Architectures Software Developer's Manual - Volume 2B - Instruction Set Reference, M-U - June 2016 (253667-059US)
(BIN) Intel Advanced Encryption Standard (AES) New Instructions Set
(BIN) Intel Advanced Encryption Standard (AES) New Instructions Set - White Paper - Rev 3.0, May 2010 (323641-001)
(BIN) Intel Advanced Vector Extensions, 2015-2016, Support in GNU C Compiler Collection, GNU Tools Cauldron 2014 (Cauldron14_AVX-512_Vector_ISA_Kirill_Yukhin_20140711)
(BIN) Intel - Advanced Vector Extensions (319433-014)
(BIN) Intel - A Novel Hashing Method Suitable for Lookup Functions (February 2012)
(BIN) Intel Architecture Code Analyzer - User's Guide - v3.0 (2017)
(BIN) Intel Architecture - Instruction Set Extensions and Future Features - Programming Reference (January 2018)
(BIN) Intel Architecture - Instruction Set Extensions and Future Features - Programming Reference - March 2020 (319433-038)
(BIN) Intel Architecture - Instruction Set Extensions and Future Features - Programming Reference - May 2019 (319433-037)
(BIN) Intel Architecture Instruction Set Extensions Programming Reference (319433-015)
(BIN) Intel Architecture Instruction Set Extensions Programming Reference (319433-017)
(BIN) Intel Architecture Instruction Set Extensions Programming Reference - April 2017 (319433-029)
(BIN) Intel Architecture Instruction Set Extensions Programming Reference - Feb 2016 (319433-024)
(BIN) Intel Architecture Instruction Set Extensions Programming Reference - January 2018 (319433-032)
(BIN) Intel Architecture Instruction Set Extensions Programming Reference - Oct 2014 (319433-022)
(BIN) Intel Architecture Instruction Set Extensions Programming Reference - Sep 2016 (319433-025)
(BIN) Intel - Avoiding AVX-SSE Transition Penalties (11MC12_Avoiding_2BAVX-SSE_2BTransition_2BPenalties_2Brh_2Bfinal)
(BIN) Intel AVX-512 Architecture - Poster - 2013 (Demikhovsky-Poster)
(BIN) Intel AVX-512 Instructions and Their Use in the Implementation of Math Functions - Slides (s1-cornea)
(BIN) Intel - Cache Allocation Technology - Whitepaper (2015)
(BIN) Intel Carry-Less Multiplication Instruction and its Usage for Computing the GCM Mode - Revision 2.0 (323640-001, May 2010)
(BIN) Intel Compiler Features + Performance Tips - Slides (2015) (IntelCompilerNERSC.201505013)
(BIN) Intel Compiler Optimization and Building for KNL - Slides (2016)
(BIN) Intel Ethernet Controller 82571EB, 82572EI, 82571GB, 82571GI - Specification Update - Rev 6.8 Nov 2014
(BIN) Intel - Improving Real-Time Performance by Utilizing Cache Allocation Technology - Whitepaper (April 2015)
(BIN) Intel IO Acceleration Technology (IOAT) Overview
(BIN) Intel IO Acceleration Technology Overview (2006)
(BIN) Intel IO Acceleration Technology Overview
(BIN) Intel - Mitigations for Jump Conditional Code Erratum - Revision 1.0 (Nov 2019)
(BIN) Intel Multimedia Instructions (MMX, SSE, SSE2, SSE3 and SSE4) - Slides
(BIN) Intel PCI Express Ethernet Networking - White Paper - Sept 2005
(BIN) Intel - PMU Sharing Guidelines (30388)
(BIN) Intel Pro-1000 PT Quad Port Bypass Server Adapter
(BIN) Intel Pro-1000 PT Quad Port LP Server Adapter - Product Brief
(BIN) Intel SIMD Architecture - Yung-Yu - UCONN (2007)
(BIN) Intel SIMD - Austronomy and Space Science - Slides (DIFX_2014-SIMD)
(BIN) Intel Technical Journal - MMX (1997-vol01-iss-3-intel-technology-journal)
(BIN) Intel - Unleash the Power of AVX-512 through Architecture, Compiler and Code Modernization - Slides - September 2012 (2016-PACT-Intel-AVX512-Tutorial-v3.0)
(BIN) Intel - _vectorcall and __regcall Demystified
(BIN) Intel Xeon E5 Product Family - Specification Update - Revision 020 - February 2017 (326510-020)
(BIN) Intel Xeon Phi Coprocessor Datasheet (April 2014)
(BIN) Intel Xeon Phi - System Software Developers Guide (Nov 2012)
(BIN) Intel Xeon Processor E5 v2 and E7 v2 Product Families - Uncore Performance Monitoring - Reference Manual - February 2014 (329468-002)
(BIN) Intel Xeon Processor E7 Family - Uncore Performance Monitoring - Programming Guide - April 2011 (325294-001)
(BIN) Intel Xeon Scalable Processor - Throughput Latency
(BIN) Interrupts in Linux - Slides (L07-LinuxEvents)
(BIN) Interval hash tree - An efficient index structure for searching object queries in large image databases (caivd99)
(BIN) Introduction to AMD GPU Programming with HIP - 2019 (AMD_GPU_HIP_training_20190906)
(BIN) Introduction to Coccinelle (Slides)
(BIN) Introduction to Debugging the FreeBSD Kernel -BSDCan 2008
(BIN) Introduction to Debugging the FreeBSD Kernel - Paper - BSDCan 2008
(BIN) Introduction to DPDK - Slides (2015)
(BIN) Introduction to Dynamic Unary Encoding (Dec 19, 2014)
(BIN) Introduction to GPUs - CS378 - Spring 2015 - Slides
(BIN) Introduction to Intel Ethernet Flow Director
(BIN) Introduction to Machine Learning - CMU-10701 - Deep Learning - Slides (Spring 2014)
(BIN) Introduction to Mathematics for Game Development - James Cowley (June 23, 2016)
(BIN) Introduction to Parallel Architectures - Josep Torrellas - CS533 (2012)
(BIN) Introduction to Probability and Statistics with R (IPSUR)
(BIN) Introduction to Python for Computational Science and Engineering - A Beginner's Guide - September 7th, 2015
(BIN) Introduction to Random Graphs - Frieze and Karonski (Book)
(BIN) Introduction to Random Graphs - Slides - 2015 (Slides_TomaszLuczak1)
(BIN) Introduction to the Pin Instrumentation Tool - Slides (27 Mar 2013)
(BIN) Introduction to x64 Assembly
(BIN) Introspection for C and its Applications to Library Robustness - 2017 (1712.01163)
(BIN) Investigation of Hardware Transactional Memory - 2015 (Andrew-Nguyen-Thesis)
(BIN) IO is Faster Than the CPU - Let's Partition Resources and Eliminate (Most) OS Abstractions (parakernel-hotos19)
(BIN) IRON File Systems (iron-sosp05)
(BIN) iSAX 2.0 - Indexing and Mining One Billion Time Series
(BIN) ispc - A SPMD Compiler for High-Performance CPU Programming (ispc_inpar_2012)
(BIN) Item-Based Collaborative Filtering Recommendation Algorithms
(BIN) It's Time for Low Latency (latency_hotos11)
(BIN) Java Callstack Trace - HTTP to JDBC - 2006 (jtrac-callstack)
(BIN) JavaScript Cheat Sheet
(BIN) JavaScript - ECMA-262 Standard (v5.1, 2011)
(BIN) Join-Idle-Queue- A Novel Load Balancing Algorithm for Dynamically Scalable Web Services - October 1, 2011 (idleq)
(BIN) Joint Strike Fighter Air Vehicle C++ Coding Standards - Dec 2005 (Doc. 2RDU00001 Rev. C)
(BIN) Jump Over ASLR - Attacking Branch Predictors to Bypass ASLR - 2016 (micro16)
(BIN) Jump the Queue to Lower Latency - USENIX - April 2015 (login_apr15_02_grosvenor_041315)
(BIN) Kam1n0 - MapReduce-based Assembly Clone Search for Reverse Engineering - 2016 (DFC16kdd)
(BIN) K - A Rewriting-Based Framework for Computations (rosu-2007-tr-c)
(BIN) k-Ary Search on Modern Processors
(BIN) KASLR is Dead - Long Live KASLR (2017)
(BIN) Keccak and the SHA-3 Standardization - Slides (Feb 6th, 2013)
(BIN) Kerncraft - A Tool for Analytic Performance Modeling of Loop Kernels - 2018 (1702.04653)
(BIN) Kernel Debugging with Windbg
(BIN) Kernel-Mode Driver Architecture Design Guide (Microsoft)
(BIN) Kernel Patch Tutorial
(BIN) Kernel Pool Exploitation on Windows 7 (BlackHat_DC_2011_Mandt_kernelpool-wp)
(BIN) KLAP - Kernel Launch Aggregation and Promotion for Optimizing Dynamic Parallelism (2016)
(BIN) KLEE - Unassisted and Automatic Generation of High-Coverage Tests for Complex Systems Programs (klee-osdi-2008)
(BIN) KMDF - How To Develop Framework Drivers - Microsoft - Slides (2007)
(BIN) Know Your HTTP Status Codes
(BIN) Latency and Bandwidth Impact on GPU Systems - 2008 (ms-proj-gpgpu-latency-bandwidth)
(BIN) LATEX for Computer Scientists - 15th May 2006
(BIN) Lazy and Speculative Execution - Microsoft Research - Slides (12th December, 2006)
(BIN) Lazy Asynchronous IO for Event-Driven Servers
(BIN) Learning a Hidden Hypergraph - 2006 (angluin06a)
(BIN) Learning Statistics with R (lsr-0.5)
(BIN) Learning with Hypergraphs - Clustering, Classification, and Embedding (2017)
(BIN) Lecture 11 - Programming on GPUs - Part 1 - Slides (Lec-11-GPU)
(BIN) Lecture Notes on AVL Trees - March 2011 (18-avl)
(BIN) Lecture Notes on Linear Algebra (2015)
(BIN) Less Hashing, Same Performance - Building a Better Bloom Filter - 2008 (10.1.1.152.579)
(BIN) Let your GPU do the Heavy Lifting in your Data Warehouse - Slides - 2013 (S3190-GPU-Heavy-Lifting-Data-Warehouse)
(BIN) Leveraging Compression in In-Memory Databases - 2012 (dbkda_2012_6_20_30160)
(BIN) libtorque - Portable Multithreaded Continuations for Scalable Event-Driven Programs
(BIN) Lightweight Contention Management for Efficient Compare-and-Swap Operations
(BIN) Linear Algebra Abridged - Sheldon Axler (13th March, 2016)
(BIN) Linear Algebra
(BIN) Linear Road - A Stream Data Management Benchmark (2004)
(BIN) Linked List Problems - Stanford (2002)
(BIN) Linux Block IO - Introducing Multi-queue SSD Access on Multicore Systems
(BIN) LinuxCon 2009 - 10Gbs Bi-directional Routing
(BIN) Linux - FS Workshop
(BIN) Linux Kernel Architecture for Device Drivers (Thomas Petazzoni)
(BIN) Linux Productivity Tools - Slides - 2019 (lisa19_maheshwari)
(BIN) Linux Symposium 2004 - All
(BIN) LMAX Disruptor - High performance alternative to bounded queues for exchanging data between concurrent threads (Disruptor-1.0)
(BIN) Locality Exists in Graph Processing - Workload Characterization on an Ivy Bridge Server
(BIN) Lock-free Concurrent Data Structures - 12 Feb 2013 (1302.2757)
(BIN) Lockless Programming - GDC 2009 - Slides (Bruce Dawson)
(BIN) Locks, Deadlocks and Synchronization - Windows Hardware and Driver Central (2006)
(BIN) Logistic Regression
(BIN) Lonestar- A Suite of Parallel Irregular Programs (ispass2009)
(BIN) Longest Common Extension with Recompression - 16th Nov 2016 (1611.05359)
(BIN) Long Gaps Between Primes - 2016 (1412.5029)
(BIN) Long-term Recurrent Convolutional Networks for Visual Recognition and Description (1411.4389v3)
(BIN) Loop Independence, Compiler Vectorization and Threading of Loops (SSE and AVX) - Intel - Slides
(BIN) Lossless Compression in Lossy Compression Systems - Stanford, EE398A - Slides (01-EntropyLosslessCoding)
(BIN) Lossless Source Coding (03_Lossless-Coding-WS12)
(BIN) Lower Bound Techniques for Data Structures
(BIN) LSM-trie - An LSM-tree-based Ultra-Large Key-Value Store for Small Data - Slides (atc15_slides_wu)
(BIN) LSM-trie - An LSM-tree-based Ultra-Large Key-Value Store for Small Data (wu15-lsm-trie)
(BIN) lwref - BSDCan2014 - FreeBSD
(BIN) Lynx - Using OS and Hardware Support for Fast Fine-Grained Inter-Core Communication (mitropoulou16-ics)
(BIN) M4 - A Visualization-Oriented Time Series Data Aggregation (p797-jugel)
(BIN) Mach - A New Kernel Foundation for UNIX Developers (accetta86)
(BIN) Mach - A New Kernel Foundation for UNIX Developers (mach_usenix86)
(BIN) Machine Learning - The High-Interest Credit Card of Technical Debt - Google (43146)
(BIN) Magazines and Vmem- Extending the Slab Allocator to Many CPUs and Arbitrary Resources
(BIN) Maintaining Knowledge about Temporal Intervals - 1983
(BIN) Making Lockless Synchronization Fast - Performance Implications of Memory Reclamation (hart_ipdps06)
(BIN) Making networking apps scream on Windows with DPDK
(BIN) Managing the Development of Large Software Systems - 1970 (waterfall)
(BIN) Managing the Google T1-5 Relational Database (10.1.1.456.9390)
(BIN) Managing Traffic with ALTQ
(BIN) Markov Chains and Random Walks
(BIN) MARX - Uncovering Class Hierarchies in C++ Programs - (NDSS 2017)
(BIN) Massively-Parallel Similarity Join, Edge-Isoperimetry, and Distance Correlations on the Hypercube - 15th Nov 2016 (1611.04999)
(BIN) Massively Parallel Sort-Merge Joins in Main Memory Multi-Core Database Systems - 2012 (p1064_martina-cezaraalbutiu_vldb2012)
(BIN) Mastering the Game of Go with Deep Neural Networks and Tree Search
(BIN) Matchings, Hamilton Cycles and Cycle Packings in Uniform Hypergraphs - 2005 (dmAE0154)
(BIN) Matchings in 3-uniform Hypergraphs (2012)
(BIN) Matchings in k-partite k-uniform Hypergraphs (Feb 17th, 2018)
(BIN) Matchings in k-partite k-uniform Hypergraphs
(BIN) Mathematics for Computer Science (2012)
(BIN) Mathematics for Computer Science (2018)
(BIN) Math for Machine Learning (2009)
(BIN) Maximally Consistent Sampling and the Jaccard Index of Probability Distributions - 2018 (1809.04052)
(BIN) Maximizing File Transfer Performance Using 10Gb Ethernet and Virtualization - FedEx Case Study - Intel (2010)
(BIN) Maximizing GPU Throughput Across Multiple Streams - Tips and Tricks - Slides (s7393-chuck-seberino-maximizing-gpu)
(BIN) Maximizing Performance of PC Games on 64-bit Platforms (AMD_GDC_2005_Mike_Wall)
(BIN) Measuring the Impact of Event Dispatching and Concurrency Models on Web Server Performance Over High-speed Networks
(BIN) MegaPipe - A New Programming Interface for Scalable Network IO
(BIN) Mellanox ConnectX-2 10GbE Cards - Product Data Sheet
(BIN) Meltdown (2018)
(BIN) Memory Barriers - a Hardware View for Software Hackers (July 23, 2010)
(BIN) Memory Efficient Hard Real-Time Garbage Collection (2003)
(BIN) Memory-Efficient Search Trees for Database Management Systems - Feb 2020 - Thesis (CMU-CS-20-101)
(BIN) Memory Ordering in Modern Microprocessors (ordering.2007.09.19a)
(BIN) Mental models, Consistency and Programming Aptitude (CRPITV78Bornat)
(BIN) MGtoolkit - A Python Package for Implementing Metagraphs (2017)
(BIN) Microsoft Portable Executable and Common Object File Format Specification - 1999 (pecoff)
(BIN) Microsoft Portable Executable and Common Object File Format Specification - Revision 8.3 (6th Feb, 2013)
(BIN) Microsoft Windows RPC Security Vulnerabilities
(BIN) Microsoft Windows - Software Development Kit - Programmer's Learning Guide - Version 2.0 (1987)
(BIN) Microsoft Windows - Software Development Kit - Programming Tools - Version 2.0 (1987)
(BIN) Mihai Patrascu - Obituary and Open Problems
(BIN) Minimal Perfect Hash Functions Made Simple - 1980 (p17-cichelli)
(BIN) MIPSpro C and C++ Pragmas (007-3587-005)
(BIN) MIPSpro MIPSpro Assembly Language Programmer's Guide (007-2418-006)
(BIN) Misomorphism - A Semiotic Model of Computer Security Circumvention - 2015 (TR2015-768)
(BIN) Mison - A Fast JSON Parser for Data Analytics (p1118-li)
(BIN) MISTRAL - Processing Relational Queries Using a Multidimensional Access Method - 2000 - Slides and Comments
(BIN) MISTRAL - Processing Relational Queries Using a Multidimensional Access Method - 2000 - Slides
(BIN) Mixed Model Universal Software Thread-Level Speculation (ICCP2013)
(BIN) Mobile Computing Research Is a Hornet's Nest of Deception and Chicanery
(BIN) Modeling High-Frequency Limit Order Book Dynamics with Support Vector Machines
(BIN) Modern C
(BIN) Modern C v2 (2019)
(BIN) Modern Microprocessors - A 90 Minute Guide
(BIN) MonetDB-X100 - Hyper-Pipelining Query Execution (CIDR 2005 P19)
(BIN) Monotone Minimal Perfect Hashing - Searching a Sorted Table with O(1) Accesses (1496770.1496856)
(BIN) Monotone Minimal Perfect Hashing - Searching a Sorted Table with O(1) Accesses - 2014 (MonotoneMinimalPerfectHashing)
(BIN) More Than You Ever Wanted to Know about Synchronization - Synchrobench, Measuring the Impact of the Synchronization on Concurrent Algorithms - 2015 (gramoli-synchrobench)
(BIN) MSDN - Compound Synchronization Objects (July 21, 1994)
(BIN) MSDN - DLLs the Dynamic Way (November, 1999)
(BIN) MSDN - Emulating Operating System Synchronization (October, 1997)
(BIN) MSDN - Multithreading for Rookies (September 24, 1993)
(BIN) MSDN - Multithreading Performance (January 31, 1996)
(BIN) MSDN - Writing Scalable Applications for Windows NT (Revision 1.0 June 6, 1995)
(BIN) MSDN - Writing Windows NT Server Applications in MFC Using IO Completion Ports (September, 1996)
(BIN) Multi-Core, Main-Memory Joins - Sort vs. Hash Revisited - 2014 (p85-balkesen)
(BIN) Multi-core with less pain - Deterministic Parallel Programming with Haskell
(BIN) Multiple Byte Processing with Full-Word Instructions - Leslie Lamport (1975)
(BIN) Name Mangling Demystified (2007)
(BIN) Near-Optimal Space Perfect Hashing Algorithms - PhD Thesis (2008)
(BIN) Networks of Collaborations - Hypergraph Modeling and Visualisation - 4th July, 2017 (1707.00115)
(BIN) Network Stack Challenges at Increasing Speeds - The 100Gbs Challenge - RedHat 2015
(BIN) Network Stack Specialization for Performance - 2013 (hotnets-final43)
(BIN) Neural Turing Machines (1410.5401v2)
(BIN) Neural Word Embedding as Implicit Matrix Factorization (5477-neural-word-embedding-as-implicit-matrix-factorization)
(BIN) New Approach for Graph Algorithms on GPU using CUDA - 2013 (10.1.1.402.6651)
(BIN) New Cardinality Estimation Algorithms for HyperLogLog Sketches (1702.01284)
(BIN) New sendfile(2) - FreeBSD (20 Feb 2015)
(BIN) Next Generation Collaborative Reversing with Ida Pro and CollabREate - 2008 (BH_US_08_Eagle_Vidas_Collabreate_paper)
(BIN) Nobody ever got fired for using Hadoop on a Cluster - Microsoft 2012 (hotcbp12)
(BIN) Nonblocking Algorithms and Scalable Multicore Programming - ACM (Samy Al Bahra)
(BIN) Notes on Differential Equations
(BIN) NTFS Cheat Sheet
(BIN) NTFS Documentation
(BIN) NTFS System Crash - Marius Tivadar - July 19th, 2017
(BIN) NT Insider - 2017-01
(BIN) NT Insider - 2017-02
(BIN) Numba - Python Compiler for NumPy-SciPy
(BIN) NumPy Binning Tutorial
(BIN) NVDIMM Block Window Driver Writer's Guide - Intel (April 2015)
(BIN) NVDIMM Namespace Specification - Intel (Revision 1.0, April 2015)
(BIN) NVDIMM-N Cookbook - A Soup-to-Nuts Primer on Using NVDIMM-Ns to Improve Your Storage Performance - 2015 (Chang-Sainio_NVDIMM_Cookbook)
(BIN) NVIDIA - Cooperative Groups - Slides - GTC 2017 (s7622-Kyrylo-perelygin-robust-and-scalable-cuda)
(BIN) NVIDIA CUDA 5.5 - Getting Started Guide for Windows - July 2013 (DU-05349-001_v5.5)
(BIN) NVIDIA - Fermi Compute Architecture - Whitepaper - v1.1
(BIN) NVIDIA - GeForce GTX 1080 Whitepaper - Gaming Perfected
(BIN) NVIDIA - GeForce GTX 1080 - Whitepaper
(BIN) NVIDIA - GeForce GTX 980 - Whitepaper
(BIN) NVIDIA GPU Computing Webinars - CUDA Memory Optimization (2011)
(BIN) NVIDIA - Optimizing Parallel Reduction in CUDA - Slides
(BIN) NVIDIA Tesla K80 Data Sheet
(BIN) NVIDIA Tesla K80 GPU Accelerator (Tesla-K80-BoardSpec-07317-001-v05)
(BIN) NVIDIA - Turing GPU Architecture - Graphics Reinveted
(BIN) NVIDIA - Understanding and Using Atomic Memory Operations - Slides (S3101-Atomic-Memory-Operations)
(BIN) NVML - Implementing Persistent Memory Applications - 2015
(BIN) NYSE OpenBook Ultra Spec v1.9
(BIN) NYU CUDA Advanced Techniques 1 - Slides
(BIN) NYU CUDA Advanced Techniques 2 - Slides
(BIN) NYU CUDA Advanced Techniques 3 - Slides
(BIN) NYU CUDA Advanced Techniques 4 - Slides
(BIN) ObCaptureObjectName
(BIN) Objconv - Instructions
(BIN) Object-relative Addressing - Compressed Pointers in 64-bit Java Virtual Machines (P107_134)
(BIN) One Billion Word Benchmark for Measuring Progress in Statistical Language Modeling (1312.3005v3)
(BIN) On End-to-End Program Generation from User Intention by Deep Neural Networks - 2015 (1510.07211v1)
(BIN) One Size Fits All - An Idea Whose Time Has Come and Gone - Relational Databases (icde05)
(BIN) On Hamilton Cycle Decompositions of r-uniform and r-partite Hypergraphs
(BIN) On the Construction and Application of Compressed Text Indexes (2004)
(BIN) On the Data Access Issue (Or Why CPUs Are Starving) - EuroSciPy 2009
(BIN) On the de Bruijn-Newman Constant (2009)
(BIN) On-the-Fly Garbage Collection - An Exercise in Cooperation - Dijkstra (1978)
(BIN) On the Implementation of Minimum Redundancy Prefix Codes (1997)
(BIN) On the k-Independence Required by Linear Probing and Minwise Independece - December 25th, 2014 (1302.5127)
(BIN) On the Performance of Bitmap Indices for High Cardinality Attributes - 2014 (822860, LBNL-54673)
(BIN) On the Quest for an Acyclic Graph - 9th Oct, 2017 (1708.01745)
(BIN) Open Crypto Audit Project - TrueCrypt (iSec)
(BIN) OpenGIS Implementation Standard for Geographic Information - Simple Feature Access - Part 2 - SQL option v1.2.1
(BIN) Open Source Kernel Enhancements for Low-Latency Sockets using Busy Poll - Intel (Whitepaper)
(BIN) OpenVMS RTL String Manipulation (STR$) Manual - April 2006 (AA-PV6MD-TK)
(BIN) Opportunistic Data Structures with Applications (2000)
(BIN) Optimization of Generalized Unary Coding (1611.03353)
(BIN) Optimizations in C++ Compilers - ACM - Nov 2019 (3371595.3372264)
(BIN) Optimizing and Interfacing with Cython - Slides - 2010 (cours_cython)
(BIN) Optimizing For AMD Ryzen - Slides (GDC2017)
(BIN) Optimizing Indirect Memory References with milk - 2016 (p299-kiriansky)
(BIN) Optimizing Parallel Prefix Operations for the Fermi Architecture
(BIN) Optimizing Parallel Reduction in CUDA (Slides)
(BIN) Optimizing Pattern Matching
(BIN) Optimizing TLS for High-Bandwidth Applications on FreeBSD - Netflix (asiabsd_2015_tls)
(BIN) Oracle 11 Data Warehousing Guide (e25554)
(BIN) Oracle 11g - Advanced Compression Whitepaper (Jan 2012)
(BIN) Oracle 11gr1 Administrator's Guide (b28310)
(BIN) Oracle 11gr1 Concepts (b28318)
(BIN) Oracle 11gr1 Data Cartridge Developer Guide (b28425)
(BIN) Oracle 11gr1 Reference (b28320)
(BIN) Oracle 11gr1 SQL Language Reference (b28286)
(BIN) Oracle 11gr2 Advanced Application Developer's Guide (e41502)
(BIN) Oracle 11gr2 Application Developer's Guide (e24435)
(BIN) Oracle 11gr2 Data Warehousing Guide (e25555)
(BIN) Oracle 11gr2 Object-Relational Developer's Guide (e11822)
(BIN) Oracle 11gr2 Performance Tuning Guide (e41573)
(BIN) Oracle 11gr2 PLSQL Language Reference (e25519)
(BIN) Oracle 11gr2 PLSQL Packages and Types (e40758)
(BIN) Oracle 11gr2 Text Reference (e24436)
(BIN) Oracle 11gr2 VLDB and Partitioning Guide (e16541)
(BIN) Oracle 12c - Utilities (E41528-05)
(BIN) Oracle - Beginning Performance Tuning (Arup Nanda)
(BIN) Oracle B-Tree Index Internals - Rebuilding the Truth (Richard Foote)
(BIN) Oracle - Fraud and Anomaly Detection Using Oracle Advanced Analytic Option 12c (fraudoaa12c-1979769)
(BIN) Oracle - Multitenant Databases (Arup Nanda)
(BIN) Oracle - New Features for Developers in 12c (Arup Nanda)
(BIN) Oracle - Partitioning Tips and Tricks (Arup Nanda)
(BIN) Oracle PLSQL Coding Guidelines (Top Coder, 2006)
(BIN) Oracle PLSQL in 12c (Arup Nanda)
(BIN) Oracle Row Pattern Matching in Sequences of Rows
(BIN) Oracle Spatial - Developing Location-Enabled Applications - Oracle Spatial Geocoding and Routing Engines
(BIN) Oracle - Tips and Techniques for Statistics Gathering (Arup Nanda)
(BIN) Oracle - Understanding Oracle Locking (Arup Nanda)
(BIN) Oracle - x86 Assembly Reference Manual (817-5477)
(BIN) Oral History of David Cutler - Computer History Museum - Feb 25 2016 (102717163-05-01-acc)
(BIN) Order-Preserving Key Compression for In-Memory Search Trees - 2003 (2003.02391)
(BIN) Origins of the Simplex Method - George B. Dantzig - 1987 (a182708)
(BIN) Outlier Detection (2005)
(BIN) Out of the Tar Pit (2006)
(BIN) Overlapping Matrix Pattern Visualization - A Hypergraph Approach (2008)
(BIN) Overplotting - Unified Solutions under Abstract Rendering
(BIN) Overview of RDMA on Windows
(BIN) Ownership and Reference Counting based Garbage Collection in the Actor World - Ponylang (2015)
(BIN) PageRank as a Function of the Damping Factor
(BIN) Pandas, SciPy, NumPy - Cheat Sheet
(BIN) Pandas v0.14.1
(BIN) Pandoc User's Guide
(BIN) Paper - B-Trees, Shadowing and Clones
(BIN) Paper - Fractal Prefetching B-Trees
(BIN) Paper - How to write Shared Libraries
(BIN) Paper - Interleaving
(BIN) Paper - The Need for Asynchronous, Zero-Copy Network IO
(BIN) Paper - The Zephyr Abstract Syntax Description Language
(BIN) Paper - Wegner Transactive Memory
(BIN) Parallel Computation - CSE260 - Lecture 9 - Matrix Multiplication (Fall 2015)
(BIN) Parallel Depth-First Search for Directed Acyclic Graphs - 2017 (nvr-2017-001)
(BIN) Parallel Depth-First Search for Directed Acyclic Graphs - 2018
(BIN) Parallel Depth-First Search for Directed Acyclic Graphs - Paper (2018)
(BIN) Parallel Depth-First Search for Directed Acyclic Graphs - Poster (2018)
(BIN) Parallel Depth-First Search for Directed Acyclic Graphs - Slides (2018)
(BIN) Parallelism in Randomized Incremental Algorithms (BGSS16)
(BIN) Parallel Lossless Data Compression on the GPU
(BIN) Parallel Programming with Transactional Memory (p38-drepper)
(BIN) Parallel Random Numbers - As Easy as 1, 2, 3 (2011)
(BIN) Parallel Scans and Prefix Sums - Slides (2013)
(BIN) Parsing a SWIFT Message (May 2007)
(BIN) Parsing Gigabytes of JSON per Second - 25 Feb 2019 (1902.08318)
(BIN) Partial Redundancy Elimination for Global Value Numbering
(BIN) Pattern Matching using Suffix Trays, Arrays and Trees (2014)
(BIN) Patterns Of Software - Tales from the Software Community
(BIN) PC Assembly Language - 2006
(BIN) PC Assembly Language (July 23, 2006)
(BIN) PCI Express Basics
(BIN) PeachPy - A Python Framework for Developing High-Performance Assembly Kernels (2013)
(BIN) Peering Inside the PE - A Tour of the Win32 Portable Executable File Format - MSDN (1994)
(BIN) Peering Inside the PE - A Tour of the Win32 Portable Executable File Format
(BIN) PE File Structure
(BIN) PE Format Layout
(BIN) PE Format Walkthrough
(BIN) PE Injection Explained
(BIN) Perfect Hash Families in Polynomial Time - Slides - October 2010 (552phf)
(BIN) Perfect Hash Functions - Slides
(BIN) Perfect Hashing for Data Management Applications - 2007 (0702159)
(BIN) Perfect Matchings in 4-uniform hypergraphs (1st Feb, 2011)
(BIN) Perfect Matchings in Large Uniform Hypergraphs with Large Minimum Collective Degree (2008)
(BIN) Perfect matchings in r-partite r-graphs (2008)
(BIN) Perfect matchings in r-partite r-graphs
(BIN) Perfect Spatial Hashing
(BIN) Performance Analysis of BSTs in System Software - 2004 (libavl)
(BIN) Performance and Reliability Analysis Using Directed Acyclic Graphs - 1987 (10.1.1.380.4352)
(BIN) Performance Evaluation of Concurrent Lock-free Data Structures on GPUs (2012)
(BIN) Performance Evaluation of Concurrent Lock-free Data Structures on GPUs - Slides (2012)
(BIN) Performing Advanced Bit Manipulations Efficiently in General-Purpose Processors (hilewitz-PerformingBitManipulations)
(BIN) Persistence Programming Models for Non-Volatile Memory - July, 2015 (HPL-2015-59)
(BIN) Persistent Memory in Windows - 2017 (Tom_Talpey_Persistent_Memory_in_Windows_Server_2016)
(BIN) Peter Hlavaty - Back To The CORE (syscan2015)
(BIN) Pin - Building Customized Program Analysis Tools with Dynamic Instrumentation (2005)
(BIN) Pin Tutorial - Slides (2007)
(BIN) PLPython - Python inside the PostgreSQL RDBMS (Slides, EuroPython 2011)
(BIN) PLWAH+ - A Bitmap Index Compressing Scheme - 2014 (jcao_c_plwah)
(BIN) Pointer Analysis
(BIN) Polynomial-Time Perfect Matchings in Dense Hypergraphs - 2013 (stoc212fp-keevash)
(BIN) Pool Tag Quick Scanning for Windows Memory Analysis - 2016
(BIN) Portable versus Open Instruction Set Architectures - 2016 (ieeemicro16_card_isa)
(BIN) Porting Linux to a New Processor Architecture (elc-2016)
(BIN) Porting of Win32 API WaitFor to Solaris (2001)
(BIN) POSH - Python Object Sharing
(BIN) POSIX Base - Issue 7 - 2013 (C138)
(BIN) PowerShell Basic Cheat Sheet
(BIN) Practical Data Compression for Modern Memory Hierarchies - July 2016 - CMU-CS-16-116 (1609.02067)
(BIN) Practical File System Design - The Be Filesystem
(BIN) Practical Implementations of Arithmetic Coding
(BIN) Practical R (2013)
(BIN) Preemptable Ticket Spinlocks - Improving Consolidated Performance in the Cloud
(BIN) Prefix B-trees - 1977
(BIN) Prefix Hash Tree - An Indexing Data Structure over Distributed Hash Tables
(BIN) Prefix Sums and Their Applications (10.1.1.128.6230)
(BIN) pre-print-oopsla16
(BIN) Princeton - Lecture 19 - Virtual Memory
(BIN) Principles of Computer System Design - An Introduction - Part II - Version 5.0 (part_ii_open_5_0)
(BIN) Principles of Distributed Computing
(BIN) Printing Floating-Point Numbers - An Always-Correct Method (fp-printing-popl16)
(BIN) Printing Floating-Point Numbers Quickly and Accurately with Integers - 2010 (dtoa-pldi2010)
(BIN) Proactor - An Object Behavioral Pattern for Demultiplexing and Dispatching Handlers for Asynchronous Events
(BIN) Probabilistic Graph and Hypergraph Matching (2008)
(BIN) Probability and Statistics Cookbook
(BIN) Processing Relational Queries Using a Multidimensional Access Method - 2000 (ubtree-comments)
(BIN) Production Tracing with Event Tracing for Windows (ETW) - MSBuild 2017 - Slides
(BIN) Program Analysis with PREfast and SAL - Erik Poll - Slides (3_StaticAnalysisPREfast)
(BIN) Program Analysis with PREfast & SAL - Slides (3_StaticAnalysisPREfast)
(BIN) Program Design in the UNIX Environment.
(BIN) Programming Interfaces to Non-Volatile Memory - Slides
(BIN) Programming Satan's Computer (AndersonNeedham)
(BIN) Programming with Hardware Lock Elision
(BIN) Programming with the x87 Floating Point Unit - Intel
(BIN) Program Synthesis By Sketching (EECS-2008-177)
(BIN) Proof of Concept or GTFO - v13 (October 18th, 2016)
(BIN) Proof of Concept or GTFO - v17 (30th December, 2017)
(BIN) Proofs and Refutations (1963)
(BIN) Providing Safe, User Space Access to Fast, Solid State Disks (2012)
(BIN) Proving the Correctness of Nonblocking Data Structures - ACM (p30-desnoyers)
(BIN) PS4 Toolchain - 2013
(BIN) P - Safe Asynchronous Event-Driven Programming - Microsoft Research Labs - November 2012 (tr-8)
(BIN) Pseudo-Random Number Generators for Vector Processors and Multicore Processors - Agner Fog (2015)
(BIN) P - Tutorial
(BIN) Putting Coroutines to Work with the Windows Runtime - Kenny Kerr and James McNellis - CppCon 2016
(BIN) PyEmu - A Multi-purpose Scriptable IA-32 Emulator (bh-usa-07-pierce-WP)
(BIN) PyParallel - How We Removed The GIL And Exploited All Cores - (PyData NYC, 2013)
(BIN) Python Bokeh Cheat Sheet
(BIN) Pythran - Enabling Static Optimization of Scientific Python Programs
(BIN) Quasi-Succinct Indices (2012)
(BIN) Quick Introduction into SAT and SMT Solvers and Symbolic Execution (2016 - Draft)
(BIN) QuickThread - Comparative analysis between QuickThread and Intel Threading Building Blocks (2009)
(BIN) QuickThread - Comparison between QuickThread and OpenMP 3.0 under system loads (2009)
(BIN) QuickThread - Programming Guide
(BIN) QuickThread - Superscalar Programming 101 - Parts 1-5 (2009)
(BIN) RadixVM - Scalable address spaces for multithreaded applications
(BIN) RadixVM - (Slides) Scalable address spaces for multithreaded applications
(BIN) Rainbow matchings in r-partite r-graphs - 2009 (v16i1r119)
(BIN) Reactor - An Object Behavioral Pattern for Demultiplexing and Dispatching Handles for Synchronous Events
(BIN) Realizing Quality Improvement Through Test Driven Development - Results and Experiences of Four Industrial Teams (nagappan_tdd)
(BIN) Real Programming in Functional Languages - James H. Morries (1981)
(BIN) Real-Time Parallel Hashing on the GPU
(BIN) Real World Concurrency
(BIN) Reasoning about Temporal Relations - A Maximal Tractable Subclass of Allen's Interval Algebra (10.1.1.57.5336)
(BIN) Recognizing Unordered Depth-First Search Trees of an Undirected Graph in Parallel (2000)
(BIN) Recollections of Early Chip Development at Intel
(BIN) Reconsidering Custom Memory Allocation (berger-oopsla2002)
(BIN) Reducing Cache Pollution Through Detection and Elimination of Non-Temporal Memory Accesses - 2010 (pap368s4)
(BIN) Reducing the Space Requirement of Suffix Trees (Kurtz_SWPracticeandExperiment_1999)
(BIN) Reevaluation of Programmed IO with Write-Combining Buffers to Improve IO Performance on Cluster Systems (NAS2015_kPIO+WC)
(BIN) Refactoring the FreeBSD Kernel with Checked C - 2020 (freebsd_checkedc)
(BIN) Reflective DLL Injection v1.0 - Stephen Fewer (31st October 2008)
(BIN) Register Level Sort Algorithm on Multicore SIMD Processors (xiaochen_rocki_IA3_SC13)
(BIN) Regular and Almost-Universal Hashing - An Efficient Implementation (1609.09840)
(BIN) Regular and Almost Universal Hashing - An Efficient Implementation - 2016 (1609.09840)
(BIN) Relative Suffix Trees - 15th Dec, 2017 (1508.02550)
(BIN) Remote Library Injection (April 6th 2004)
(BIN) Repeating History Beyond ARIES - C. Mohan (VLDB Conf, 1999)
(BIN) Replacing Suffix Trees with Enhanced Suffix Arrays (2004)
(BIN) Resumable Functions v3 - Microsoft C++ (n4286)
(BIN) Rethinking SIMD Vectorization for In-Memory Databases (2015)
(BIN) Retroactive Data Structures (2012)
(BIN) Retrofitting Word Vectors to Semantic Lexicons - 2015 (15HLT-retrofitting-word-vectors)
(BIN) Reverse Engineering for Beginners
(BIN) Reverse-Engineering Instruction Encodings - 2000 (derive-usenix01)
(BIN) Rewriting History - USC FBE Finance Seminar - (F_2-15-07_MALLOY-Anonymous)
(BIN) Rewriting x86 Binaries without Code Producer Cooperation (wartell12thesis)
(BIN) Rich vs King - The Entrepreneur's Dilemma - Harvard (2006)
(BIN) Ring 0 to Ring-1 Attacks - Hyper-V IPC Internals - Alex Ionescu (syscan2015)
(BIN) Rise of the VMs (Slides)
(BIN) Robust Combinatorial Optimization with Exponential Scenarios (November 10th, 2006)
(BIN) Safe Concurrent Programming and Execution
(BIN) Safe Memory Reclamation for Dynamic Lock-Free Objects Using Atomic Reads and Writes - 2002 (podc-2002)
(BIN) SALSA - Scalable and Low Synchronization NUMA-aware Algorithm for Producer-Consumer Pools (spaa049-gidron)
(BIN) Satisfiability Modulo Theories - An Appetizer - Microsoft Research - Slides - 2009 (sbmf09-slides)
(BIN) SC11 - Overview of RDMA on Windows
(BIN) Scalable Lock-Free Dynamic Memory Allocation (pldi-2004)
(BIN) Scaling Address Space Operations on Linux with TSX (2011)
(BIN) Scheduling, Thread Context and Synchronization - Windows Hardware and Driver Central (2004)
(BIN) SciPy 1.0 - Fundamental Algorithms for Scientific Computing in Python - 2020 (s41592-019-0686-2)
(BIN) Scrambled Linear Pseudorandom Number Generators
(BIN) Screaming Fast Galois Field Arithmetic Using Intel SIMD Instructions (FAST-2013-GF)
(BIN) Scriptable Operating Systems with Lua
(BIN) SCSI Command Table
(BIN) Security Engineering - Ross Anderson (v1)
(BIN) SEDA - An Architecture for Well-Conditioned, Scalable Internet Services - Deck (seda-sosp01-talk)
(BIN) SEDA - An Architecture for Well-Conditioned, Scalable Internet Services - Dissertation (mdw-phdthesis)
(BIN) SEDA - An Architecture for Well-Conditioned, Scalable Internet Services (seda-sosp01)
(BIN) Sega Saturn (ST-238-R1-051795)
(BIN) Self-Adjusting Binary Search Trees (1985)
(BIN) Self-Verifying Execution (Position Paper) - Microsoft Research (2016)
(BIN) Semantic Patches - Documenting and Automating Collateral Evolutions in Linux Device Drivers (ols07-padioleau)
(BIN) Seminars - A Collection of Materials on Seminar Approaches and Evaluation Strategies
(BIN) Sequence to Sequence Learning with Neural Networks (1409.3215v3)
(BIN) Sequent Calculus as a Compiler Intermediate Language - ICFP (2016)
(BIN) Shining Light on Shadow Stacks - 7 Nov 2018 (1811.03165)
(BIN) Shuffler - Fast and Deployable Continuous Code Re-Randomization - 2016 (shuffler-osdi16)
(BIN) Shuffle - Tips and Tricks - Slides - GPU Tech Conf 2013 (S3174)
(BIN) SIMD at Insomniac Games (How We Do The Shuffle) - Slides - 2015
(BIN) SIMD Compression and the Intersection of Sorted Integers (1401.6399v11)
(BIN) SIMD Compression and the Intersection of Sorted Integers - 2015 (1401.6399v12)
(BIN) SIMD Compression and the Intersection of Sorted Integers (simdcompressionarxiv)
(BIN) SIMD Parallelization of Applications that Traverse Irregular Data Structures
(BIN) SIMD Vectorization of Histogram Functions (10.1.1.80.9041)
(BIN) SIMNET and Beyod - A History of the Development of Distributed Simulation - 2015 (2015_FellowPaper_Miller)
(BIN) Simple and Space-Efficient Minimal Perfect Hash Functions - 2007 (wads07)
(BIN) Simple Image File Formats - PPM Format
(BIN) Simple implementation of deletion from open-address hash table (0909.2547)
(BIN) Sine and Cosine using CORDIC
(BIN) SipHash - A Fast, Short-Input PRF - 18th Sept 2012 (2117_siphash)
(BIN) Skip Lists - A Probabilistic Alternative to Balanced Trees - 1990 (pugh-skiplists-cacm1990)
(BIN) SLAM and Static Driver Verifier- Technology Transfer of Formal Methods inside Microsoft (tr-2004-08)
(BIN) SMT and Z3 - Microsoft Research - Slides (2009)
(BIN) Snel - SQL Native Execution for LLVM - 21 Feb 2020 (2002.09449)
(BIN) Software Engineering Code of Ethics
(BIN) Software Tracing - Slides - Microsoft 2003
(BIN) Software Transactional Memory - Why Is It Only a Research Toy (p46-cascaval)
(BIN) Solaris 10 System Administration Guide - Solaris Fibre Channel Storage Configuration and Multipathing Support Guide
(BIN) Solaris 11 - Cheat Sheet (1556378)
(BIN) Solaris Dynamic Tracing Guide (817-6223)
(BIN) Solaris Internals - Core Kernel Architecture
(BIN) Sorting improves word-aligned bitmap indexes - 2014 (0901.3751v6)
(BIN) SpaceJMP - Programming with Multiple Virtual Address Spaces - 2016 (spacejmp_asplos16)
(BIN) SPARC - v9 Architecture Manual
(BIN) Specialising Dynamic Techniques For Implementing The Ruby Programming Language
(BIN) SPECK - A Kernel for Scalable Predictability (rtas15speck)
(BIN) Spectre Attacks - Exploiting Speculative Execution (2018)
(BIN) Speeding up Networking - Precision IO
(BIN) Spin-Based Reader-Writer Synchronization for Multiprocessor Real-Time Systems_
(BIN) Spread Unary Coding (1412.6122)
(BIN) SQLGraph - An Efficient Relational-Based Property Graph Store - 2015 (43287)
(BIN) Staring Into The Abyss - An Evaluation of Concurrency Control with One Thousand Cores (p209-yu)
(BIN) Statis - Flexible Transactional Storage (EECS-2010-2)
(BIN) Statistically adaptive learning for a general class of cost functions (SA L-BFGS) (1209.0029v3)
(BIN) Stochastic Gradient Descent Tricks (Microsoft Research, 2012)
(BIN) STOPLESS - A Real-Time Garbage Collector for Multiprocessors (10.1.1.108.322)
(BIN) Storing a Sparse Table with O(1) Worst Case Access Time - 1984 (fks-perfecthash)
(BIN) Stratified B-trees and Versioning Dictionaries - 2011 (1103.4282v2)
(BIN) Stratified B-trees and Versioning Dictionaries - 30 March 2011 (1103.4282v2)
(BIN) Stratified Synthesis - Automatically Learning the x86-64 Instruction Set - 2016 (pldi16-strata)
(BIN) Streaming Data Mining
(BIN) Streaming Store Instructions in the Intel Xeon Phi coprocessor - Slides (2012)
(BIN) Strongly Universal String Hashing is Fast - 15 May 2014 (1202.4961)
(BIN) Structured Deferral - Synchronization via Procrastination - ACM (p20-mckenney)
(BIN) Structured Exception Handler Exploitation (17505)
(BIN) Suffix Trees - Slides (Ben Langmead, Johns Hopkins)
(BIN) Sum of Degrees of Vertices Theorem - Slides
(BIN) System V Application Binary Interface (ABI) AMD64 Architecture Processor Supplement - v0.99.6 (October 7, 2013)
(BIN) System V Application Binary Interface AMD64 Architecture Processor Supplement
(BIN) Tackling Latency Using FG (TR2011-706)
(BIN) Taming Win32 Threads with Static Analysis - Slides (08161-yangjasonyue-slides)
(BIN) Tango - Distributed Data Structures over a Shared Log
(BIN) TCP Fast Open
(BIN) Temporally Bounding TSO for Fence-Free Asymmetric Synchronization - 2015 (asplos2015-tbtso)
(BIN) Ten Lessons I Wish I Had Learned Before I Started Teaching Differential Equations
(BIN) TensorFlow - Large-Scale Machine Learning on Heterogeneous Distributed Systems (Nov 9th, 2015)
(BIN) Ten Years with DragonFlyBSD Network Stack (2017)
(BIN) Tesla - GPU Computing - Past, Present and Future - Slides (2011)
(BIN) Test-driving Intel Xeon Phi - 2013 (p137)
(BIN) TestU01 - A Software Library in ANSI C for Emperical Testing of Random Number Generators - 2013 (guideshorttestu01)
(BIN) The 12 Commandments of Synchronization - October 4, 2011 (10.1.1.227.3871)
(BIN) The Allure of Machine Learning - Azure ML
(BIN) The ART of Practical Synchronization (2016)
(BIN) The AWK Programming Language (1988)
(BIN) The Bias Against Creativity - Why People Desire But Reject Creative Ideas (Cornell, 1-1-2011)
(BIN) The Burrows-Wheeler Algorithm - Daniel Schiller (August 5th, 2012)
(BIN) The Bw-Tree - A B-tree for New Hardware Platforms (Microsoft Research)
(BIN) The Cache Performance and Optimizations of Blocked Algorithms - 1991 (lam-asplos91)
(BIN) The C and C++ Memory Model
(BIN) The chemfp Project - 2019 (s13321-019-0398-8)
(BIN) The Continuous Linked Settlement (CLS) Foreign Exchange Settlement System
(BIN) The Dark Side of Winsock (DC_13-Levin)
(BIN) The Datacenter as a Computer - Designing Warehouse-Scale Machines - 3rd Edition (00874ed3v01y201809cac046)
(BIN) The Dataflow Model - A Practical Approach to Balancing Correctness, Latency, and Cost in Massive-Scale, Unbounded, Out-of-Order Data Processing (p1792-Akidau)
(BIN) The Data Plane Development Kit (DPDK) - What it is and where it's going - Slides
(BIN) The Death of Optimizing Compilers (slides-djb-20150416-a4)
(BIN) The Debugging Application Programming Interface - MSDN (1992)
(BIN) The Design and Implementation of Modern Column-Oriented Database Systems (abadi-column-stores)
(BIN) The Design of a High-Performance File Server - 1989 (10.1.1.38.5481)
(BIN) The Development of JOVIAL - 1978 (p203-schwartz-jovial)
(BIN) The DragonFlyBSD System (2004)
(BIN) The Economics of Immediate Gratification (jbdmfinal)
(BIN) The Elements of Statistical Learning - Data Mining, Inference and Prediction - 2nd Edition (ESLII_print4)
(BIN) The Evolution of Effective B-tree Page Organization and Techniques - A Personal Account - David Lomer, Microsoft Research (a1-lomet)
(BIN) The Evolution of Operating Systems (2001b)
(BIN) The Forgotten Interface - Windows Named Pipes - Gil Cohen - Slides (2017)
(BIN) The Function of Dream Sleep - Nature Vol. 304 (14th July, 1983)
(BIN) The Hideous Name - 1985 (pike85hideous)
(BIN) The IBM POWER8 Review - Challenging the Intel Xeon - Anandtech (2015)
(BIN) The Impact of the Lambda Calculus in Logic and Computer Science (1997)
(BIN) The Influence of Organizational Structure On Software Quality - An Empirical Case Study (tr-2008-11)
(BIN) The K Semantic Framework (CS422-Spring-2010-K)
(BIN) The Linux Kernel Hidden Inside Windows 10 - Alex Ionescu - Slides - Black Hat 2016
(BIN) The Linux Scheduler - A Decade of Wasted Cores - 2016 (eurosys16-final29)
(BIN) The Little Book of Semaphores - Version 2.1.5 (downey08semaphores)
(BIN) The Longest Common Extension Problem Revisited and Applications to Approximate String Searching (2010)
(BIN) The Memory Pool System
(BIN) The Microarchitecture of Intel, AMD and VIA CPUs - An Optimization Guide for Assembly Programmers and Compiler Makers (2018)
(BIN) The Need for Asynchronous, Zero-Copy Network IO - Drepper (Slides)
(BIN) The Night Watch
(BIN) The Notorious Four-Color Problem
(BIN) The NT Insider (2017-01)
(BIN) The NumPy Array - A Structure for Efficient Numerical Computation (2011)
(BIN) The NumPy Array - A Structure for Efficient Numerical Computation - 8th Feb 2011 (1102.1523)
(BIN) Theory and Practice of Monotone Minimal Perfect Hashing
(BIN) Theory of Locality Sensitive Hashing - CS246 Stanford (Slides)
(BIN) The Probabilistic Relevance Framework - BM25 and Beyond
(BIN) The Query-flow Graph - Model and Applications (2008)
(BIN) The ReactOS Project - An Open Source OS Platform for Learning - Slides - Ionescu (2007)
(BIN) The RecordLinkage Package - Detecting Errors in Data
(BIN) The Reversal Test - Eliminating Status Quo Bias in Applied Ethics
(BIN) The Reyes Image Rendering Architecture - 1987
(BIN) The RFB Protocol (v3.0, 26-Nov-2010)
(BIN) The RFB Protocol v3.8 (26 Nov 2010)
(BIN) The R Inferno (30th April, 2011)
(BIN) Thermometer Encoding - One Hot Way To Resist Adversarial Examples - ICLR 2018
(BIN) The Road Towards a Linux TSN (Time-Sensitive Network) Infrastructure - Intel - Slides - 2018 (ELC-2018-USA-TSNonLinux)
(BIN) The Robust Beauty of Improper Linear Models in Decision Making - July 1979
(BIN) The Roots of Trigonometric Integrals - 1950 (597490)
(BIN) The Saddest Moment
(BIN) These Are Not Your Grand Daddys CPU Performance Counters - CPU Hardware Performance Counters For Security - Slides (2015)
(BIN) The Significance of SIMD, SSE and AVX - Intel - Slides (3a_SIMD)
(BIN) The Skein Hash Function Family - v1.2 - 15 Sep 2009 (skein1.2)
(BIN) The Slow Winter
(BIN) The Transactional Memory - Garbage Collection Analogy (analogy_oopsla07)
(BIN) The Trill Incremental Analytics Engine (MSR-TR-2014-54)
(BIN) The Ubiquitous B-Tree - 1979 (comer-b-tree)
(BIN) The UNIX Time-Sharing System (1974)
(BIN) The UVM Virtual Memory System (1999)
(BIN) The VAD Tree - A Process-Eye View of Physical Memory (2007)
(BIN) The Vertica Analytic Database- C-Store 7 Years Later (p1790_andrewlamb_vldb2012)
(BIN) Things You Didn't Known About Portable Executable File Format (PECOFF) - Slides - 2011 (BH_US_11_VuksanPericin_PECOFF_Slides)
(BIN) Thirty-three Miniatures - Mathematical and Algorithmic Applications of Linear Algebra - 2017 (stml-53-matousek-1)
(BIN) This World of Ours
(BIN) Threads and DragonFlyBSD - Slides - 2009 (luciani_dcbsdcon2009)
(BIN) Thrill - High-Performance Algorithmic Distributed Batch Data Processing in C++ - Slides (2016)
(BIN) Thrill - High-Performance Algorithmic Distributed Batch Data Processing with C++ (1608.05634)
(BIN) Thrust - A Productivity-Oriented Library for CUDA (2012)
(BIN) Time, Clocks, and the Ordering of Events in a Distributed System - Leslie Lamport, 1978 (p558-lamport)
(BIN) TinyLFU - A Highly Efficient Cache Admission Policy (1512.00727)
(BIN) Tokutek - Data Structures and Algorithms for Big Databases
(BIN) Tokutek - Fractal Tree Technology and the Art of Indexing
(BIN) Tokutek - Solving the Challenges of Big Databases with MySQL (MySQL Connect 2012)
(BIN) Topic Indexing - Slides
(BIN) Topics in IRIX 6.5 Programming
(BIN) Topological Transformation Approaches To Database Query Processing (2015)
(BIN) To Search or to Crawl - Toward a Query Optimizer for Text-Centric Tasks (sigmod2006)
(BIN) Towards a Database System for Large-scale Analytics on Strings - PhD Thesis (2015)
(BIN) Towards Deep Symbolic Reinforcement Learning - 2016 (1609.05518)
(BIN) Towards Deep Symbolic Reinforcement Learning - 2016 (1609.05518v2)
(BIN) Towards End-to-End Speech Recognition with Recurrent Neural Networks (graves14)
(BIN) To Wash It All Away
(BIN) Trace-based Just-in-Time Type Specialization for Dynamic Languages - 2009 (tracemonkey)
(BIN) Tracing Function Calls in the Windows NT Kernel - PhD Thesis - 2015 (BPTX_2014_2_11320_0_348076_0_164038)
(BIN) Tracing Privileged Memory Accesses to Discover Software Vulnerabilities (2015)
(BIN) Tracing the Meta-Level - PyPy’s Tracing JIT Compiler - 2009 (bolz-tracing-jit-final)
(BIN) Track Join - Distributed Joins with Minimal Network Traffic (sigmod14II)
(BIN) Training of CC4 Neural Network using Unary and Spread-Unary Inputs (Potluri_okstate_0664M_14453)
(BIN) Transactional Memory - CS4021 - Slides
(BIN) Transparent Pointer Compression for Linked Data Structures (2005-06-12)
(BIN) Traps and Pitfalls of Topic-Biased PageRank
(BIN) Tries and String Matching - Slides - 2009 (Small09)
(BIN) Tries and Suffix Tries - Slides (Ben Langmead, Johns Hopkins)
(BIN) Trig Cheat Sheet
(BIN) True IOMMU Protection from DMA Attacks - When Copy is Faster than Zero Copy - 2016 (cim-asplos-2016)
(BIN) TruRank - Taking PageRank to the Limit
(BIN) Tuning a Database Reorganization for Maximum Speed (Quest Software)
(BIN) Twenty-Five Comparators is Optimal when Sorting Nine Inputs (and Twenty-Nine for Ten) (1405.5754)
(BIN) Two-Way String Matching (1991)
(BIN) Ultrafast and Memory-Efficient Alignment of Short DNA Sequences to the Human Genome - 2009 (gb-2009-10-3-r25)
(BIN) Unary Coding for Neural Network Learning (1009.4495)
(BIN) Unary Negation - 2013 (1309.2069)
(BIN) Understanding and Expressing Scalable Concurrency - Aaron Turon - Thesis (2013)
(BIN) Understanding and Improving Bloom Filter Configuration for Lazy Address-set Disambiguation (2011)
(BIN) Understanding and Using Atomic Memory Operations - GTC 2013 - Slides (S3101-Atomic-Memory-Operations)
(BIN) Understanding Deep Learning Requires Rethinking Generalization - 2016 (1611.03530v1)
(BIN) Understanding Latency Hiding on GPUs - August 12th, 2016 (EECS-2016-143)
(BIN) Understanding Open Market Operations
(BIN) Understanding the Basis of the Kalman Filter Via a Simple and Intuitive Derivation (2012)
(BIN) Understanding the Overheads of Launching CUDA Kernels (Poster17-moc)
(BIN) Understanding the Performance of PCI Express Systems - Xilinx (October, 2014)
(BIN) Understanding the Python GIL - David Beazley (2010)
(BIN) Undocumented PECOFF (BH_US_11_VuksanPericin_PECOFF_WP)
(BIN) Unified Memory - Notes on GPU Data Transfers (2017)
(BIN) Uninformed v4a1 - Improving Automated Analysis of Windows x64 Binaries (2006)
(BIN) Universal and Perfect Hashing (lect1004)
(BIN) UNIX IO and its Slouch Towards Multicore NUMA (libtorque)
(BIN) UNIX Time Sharing System - UNIX Programmer's Manual - Seventh Edition, Volume 1A - January, 1979 (v7vol1a)
(BIN) UNIX Time Sharing System - UNIX Programmer's Manual - Seventh Edition, Volume 2A - January, 1979 (v7vol2a)
(BIN) UNIX Time Sharing System - UNIX Programmer's Manual - Seventh Edition, Volume 2B - January, 1979 (v7vol2b)
(BIN) Unmixed d-uniform and r-partite Hypergraphs - 2016 (1605.02655)
(BIN) Unreliable Guide to Hacking the Linux Kernel (2000)
(BIN) UofW - Memory Hierarchy
(BIN) uops.info - Characterizing Latency, Throughput, and Port Usage of Instructions on Intel Microarchitectures - 10 Oct 2018 (1810.04610)
(BIN) User Mode Memory Page Management
(BIN) Using CUDA in Practice - GPU Programming - CSE 591 - Slides
(BIN) Using Graphics Processors for Parallelizing Hash-based Data Carving - 2009 (10.1.1.405.6531)
(BIN) Using Memory Management to Detect and Extract Illegitimate Code for Malware Analysis - Slides - 2012
(BIN) Using non-volatile memory (NVDIMM-N) as byte-addressable storage in Windows Server 2016 (P470)
(BIN) Variants of Mersenne Twister Suitable for Graphic Processors - 21 Mar 2012 (1005.4973)
(BIN) VAX-VMS Internals 2 Student Workbook (Oct-86, EY-2280E-SG-0001)
(BIN) Vectorized Bloom Filters for Advanced SIMD Processors - Columbia - Slides
(BIN) Vectorized Bloom Filters for Advanced SIMD Processors (damon14)
(BIN) Verification of the Tree-Based Hierarchical Read-Copy Update in the Linux Kernel - 10th October, 2016 (1610.03052)
(BIN) Verification Techniques
(BIN) Versioned external-memory dictionaries with optimal query-update tradeoffs - 2011 (1103.2566v2)
(BIN) Vim Book (vimbook-OPL)
(BIN) Vim for Humans
(BIN) Virtualization Without Direct Execution or Jitting - Designing a Portable Virtual Machine Infrastructure
(BIN) Virtual Threads - 2000 (cs263_cheong_reiss)
(BIN) Visual Studio, Microsoft Portable Executable and Common Object File Format Specification - Revision 9.3 - 29th Dec, 2015 (pecoff_v93)
(BIN) Vulcan - Binary Transformation in a Distributed Environment (tr-2001-50)
(BIN) Wake-up Latencies for Processor Idle States on Current x86 Processors - Slides (2014)
(BIN) Warp Shuffles, and Reduction and Scan Operations - CUDA - Slides
(BIN) Weaving Relations for Cache Performance - 2001 (P169)
(BIN) Weird Things that Surprise Academics Trying to Commercialize a Static Checking Tool (spin05-coverity)
(BIN) What Every Programmer Should Know About Memory - Ulrich Drepper (2007)
(BIN) What Happens During a Join - Dissecting CPU and Memory Optimization Effects (P339)
(BIN) What's New In Apple File Systems - Slides - WWDC 2019
(BIN) What's Wrong With Deep Learning (lecun-20150610-cvpr-keynote)
(BIN) When Corrections Fail - The Persistence of Political Misperceptions (nyhan-reifler)
(BIN) When Prefetching Works, When It Doesn't, and Why - ACM, 2012 (lee_taco12)
(BIN) When To Use Splay Trees (2007)
(BIN) Why Aren't Operating Systems Getting Faster As Fast As Hardware - WRL-TN-11 (October 1989)
(BIN) Why BitBlt was So Successful - SIGGRAPH 84 (pike84bitblt)
(BIN) Why Modern CPUs Are Starving And What Can Be Done About It - Francesc Alted (StarvingCPUs-CISE-2010)
(BIN) Why Rust (2015)
(BIN) Why Threads Are A Bad Idea (For Most Purposes) - John Ousterhout (Sept 1995)
(BIN) Win32 Static Analysis in Python - Ero Carrera - Sabre Security GmbH (Slides)
(BIN) WinDbg - A to Z (Slides)
(BIN) WinDbg Cheat Sheet
(BIN) Windows 10 Control Flow Guard Internals (mj0011)
(BIN) Windows 10 Internals
(BIN) Windows 8 Registered IO (SAC-593T_Briggs)
(BIN) Windows and Some Differences from Linux - Slides (Brian Railing)
(BIN) Windows - A Software Engineering Odyssey (Lucovsky)
(BIN) Windows Assembly Programming Tutorial - Jeff Huang (v1.02, Dec 10 2003)
(BIN) Windows Commands
(BIN) Windows - Disk Subsystem Performance Analysis (March 2004)
(BIN) Windows Error Codes
(BIN) Windows Filter Manager - Slides (2003)
(BIN) Windows Kernel Architecture Internals (Dave_Probert_1)
(BIN) Windows Kernel Attacks through User-Mode Callbacks (Black Hat USA 2011)
(BIN) Windows Kernel Debugging Tutorial
(BIN) Windows Kernel Internals - Advance Virtual Memory
(BIN) Windows Kernel Internals - Cache Manager
(BIN) Windows Kernel Internals - IO Architecture
(BIN) Windows Kernel Internals - Lightweight Procedure Calls
(BIN) Windows Kernel Internals - NTFS
(BIN) Windows Kernel Internals - NT Registry Implementation
(BIN) Windows Kernel Internals - Object Manager
(BIN) Windows Kernel Internals - Overview
(BIN) Windows Kernel Internals - Synchronization
(BIN) Windows Kernel Internals - Traps, Interrupts and Exceptions
(BIN) Windows Kernel - MSDN Export (7th Feb, 2019)
(BIN) Windows Logon Forensics - 30th Jan 2013 (6928)
(BIN) Windows Network Services Internals - Hivercon 2003 (Jean-Baptiste Marchand)
(BIN) Windows New Security Features - Control Flow Guard - Slides (MR201412_Control_Flow_Guard_ENG)
(BIN) Windows NT pagefile.sys Virtual Memory Analysis
(BIN) Windows Persistent Memory Support (20160811_S301B_Christiansen)
(BIN) Windows Privilege Escalation Through LPC and ALPC Interfaces (June, 2008)
(BIN) Windows Research Kernel - Design Notes (David Cutler et al, 1989)
(BIN) Windows - Timers, Timer Resolution, and Development of Efficient Code (10 June 2016)
(BIN) Windows User-Mode Drivers - Alex Ionescu (2012)
(BIN) Witnesses for Non-Satisfiability of Dense Random 3CNF Formulas (May 9th, 2006)
(BIN) Writing a Simple Operating System from Scratch - Nick Blundell - Dec 2010
(BIN) Writing Linux Device Drivers in Assembly Language - 2002
(BIN) Writing Network Drivers in Go (2018-ixy-go)
(BIN) Writing Network Drivers in Rust (2018-ixy-rust)
(BIN) Writing R Extensions
(BIN) x86 Intrinsics Cheatsheet v2.1
(BIN) x86 Intrinsics Cheatsheet v2.2
(BIN) Xorshift RNGs - George Marsaglia (2003)
(BIN) X-Ray - A Function Call Tracing System
(BIN) xv6 - a simple, Unix-like teaching operating system (Aug 28 2012, draft 7)
(BIN) ZeroMQ
(BIN) ZFS Administration Guide (2007)
(BIN) ZFS On-Disk Data Walk (Or, Where's My Data) - Slides (2008)
(BIN) ZFS On-Disk Specification - Draft - 2006 (ondiskformat0822)