This document discusses gameplay systems for the PlayStation 3's SPUs (Synergistic Processing Units). It introduces AsyncMobyUpdate, which moves update classes to the SPUs using user-supplied code fragments. Guppys are a lighter alternative to MobyInstances that use SPUs for all updates. AsyncEffects allow easy fire-and-forget SPU effects. Memory addressing strategies like direct, direct indexed, and indirect indexed are covered. Typical usage involves fetching multiple related instance streams in a fragment to avoid stalls.
Simple, fast, and scalable torch7 tutorialJin-Hwa Kim
A tutorial based on basic information of Torch7. It covers installation, simple runable codes, tensor manipulations, sweep out key-packages and post-hoc audience q&a.
We all make mistakes while programming and spend a lot of time fixing them.
One of the methods which allows for quick detection of defects is source code static analysis.
A short and fast journey through some of the profiling options available in the Ruby 2.x world, including a look at flamegraphs and new ways of tracking memory usage in the MRI.
Simple, fast, and scalable torch7 tutorialJin-Hwa Kim
A tutorial based on basic information of Torch7. It covers installation, simple runable codes, tensor manipulations, sweep out key-packages and post-hoc audience q&a.
We all make mistakes while programming and spend a lot of time fixing them.
One of the methods which allows for quick detection of defects is source code static analysis.
A short and fast journey through some of the profiling options available in the Ruby 2.x world, including a look at flamegraphs and new ways of tracking memory usage in the MRI.
We all make mistakes while programming and spend a lot of time fixing them.
One of the methods which allows for quick detection of defects is source code static analysis.
Description
At Stitch Fix most application logs are output in a structured JSON format for simpler debugging and downstream consumption.
In this talk we’ll cover in more detail why structured logs are useful and provide leverage, caveats to using them, and how simple it is to get one going with Python.
Abstract
At Stitch Fix most application logs are output in a structured JSON format for simpler debugging and downstream consumption. For example, data scientists can add a field to their application log and it will automatically turn up as a parsed field in Elasticsearch for easy dashboarding and querying via Kibana, or be easily found and queried in Presto. In this talk we’ll cover in more detail why structured logs are useful and provide leverage, caveats to using them, and how simple it is to get one going with Python.
PVS-Studio and Continuous Integration: TeamCity. Analysis of the Open RollerC...Andrey Karpov
One of the most relevant scenarios for using the PVS-Studio analyzer is its integration into CI systems. Even though a project analysis by PVS-Studio can already be embedded with just a few commands into almost any continuous integration system, we continue to make this process even more convenient. PVS-Studio now supports converting the analyzer output to the TeamCity format-TeamCity Inspections Type. Let's see how it works.
Over-the-Air: How we Remotely Compromised the Gateway, BCM, and Autopilot ECU...Priyanka Aash
We, Keen Security Lab of Tencent, have successfully implemented two remote attacks on the Tesla Model S/X in year 2016 and 2017. Last year, at Black Hat USA, we presented the details of our first attack chain. At that time, we showed a demonstration video of our second attack chain, but without technical aspects. This year, we are willing to share our full, in-depth details on this research.
In this presentation, we will explain the inner workings of this technology and showcase the new capability that was developed in the Tesla hacking 2017. Multiple 0-days of different in-vehicle components are included in the new attack chain.
We will also present an in-depth analysis of the critical components in the Tesla car, including the Gateway, BCM(Body Control Modules), and the Autopilot ECUs. For instance, we utilized a code-signing bypass vulnerability to compromise the Gateway ECU; we also reversed and then customized the BCM to play the Model X "Holiday Show" Easter Egg for entertainment.
Finally, we will talk about a remote attack we carried out to successfully gain an unauthorized user access to the Autopilot ECU on the Tesla car by exploiting one more fascinating vulnerability. To the best of our knowledge, this presentation will be the first to demonstrate hacking into an Autopilot module.
Scene Graphs & Component Based Game EnginesBryan Duggan
A presentation I made at the Fermented Poly meetup in Dublin about Scene Graphs & Component Based Game Engines. Lots of examples from my own game engine BGE - where almost everything is a component. Get the code and the course notes here: https://github.com/skooter500/BGE
Using GPUs to handle Big Data with Java by Adam Roberts.J On The Beach
Modern graphics processing units (GPUs) are efficient general-purpose stream processors. Learn how Java can exploit the power of GPUs to optimize high-performance enterprise and technical computing applications such as big data and analytics workloads. This presentation covers principles and considerations for GPU programming from Java and looks at the software stack and developer tools available. It also presents a demo showing GPU acceleration and discusses what is coming in the future.
syzkaller is an unsupervised, coverage-guided Linux syscall fuzzer.
The presentation covers basic of operation of the fuzzer, gives tutorial on how to run it and how to extend it to fuzz new drivers.
We all make mistakes while programming and spend a lot of time fixing them.
One of the methods which allows for quick detection of defects is source code static analysis.
Description
At Stitch Fix most application logs are output in a structured JSON format for simpler debugging and downstream consumption.
In this talk we’ll cover in more detail why structured logs are useful and provide leverage, caveats to using them, and how simple it is to get one going with Python.
Abstract
At Stitch Fix most application logs are output in a structured JSON format for simpler debugging and downstream consumption. For example, data scientists can add a field to their application log and it will automatically turn up as a parsed field in Elasticsearch for easy dashboarding and querying via Kibana, or be easily found and queried in Presto. In this talk we’ll cover in more detail why structured logs are useful and provide leverage, caveats to using them, and how simple it is to get one going with Python.
PVS-Studio and Continuous Integration: TeamCity. Analysis of the Open RollerC...Andrey Karpov
One of the most relevant scenarios for using the PVS-Studio analyzer is its integration into CI systems. Even though a project analysis by PVS-Studio can already be embedded with just a few commands into almost any continuous integration system, we continue to make this process even more convenient. PVS-Studio now supports converting the analyzer output to the TeamCity format-TeamCity Inspections Type. Let's see how it works.
Over-the-Air: How we Remotely Compromised the Gateway, BCM, and Autopilot ECU...Priyanka Aash
We, Keen Security Lab of Tencent, have successfully implemented two remote attacks on the Tesla Model S/X in year 2016 and 2017. Last year, at Black Hat USA, we presented the details of our first attack chain. At that time, we showed a demonstration video of our second attack chain, but without technical aspects. This year, we are willing to share our full, in-depth details on this research.
In this presentation, we will explain the inner workings of this technology and showcase the new capability that was developed in the Tesla hacking 2017. Multiple 0-days of different in-vehicle components are included in the new attack chain.
We will also present an in-depth analysis of the critical components in the Tesla car, including the Gateway, BCM(Body Control Modules), and the Autopilot ECUs. For instance, we utilized a code-signing bypass vulnerability to compromise the Gateway ECU; we also reversed and then customized the BCM to play the Model X "Holiday Show" Easter Egg for entertainment.
Finally, we will talk about a remote attack we carried out to successfully gain an unauthorized user access to the Autopilot ECU on the Tesla car by exploiting one more fascinating vulnerability. To the best of our knowledge, this presentation will be the first to demonstrate hacking into an Autopilot module.
Scene Graphs & Component Based Game EnginesBryan Duggan
A presentation I made at the Fermented Poly meetup in Dublin about Scene Graphs & Component Based Game Engines. Lots of examples from my own game engine BGE - where almost everything is a component. Get the code and the course notes here: https://github.com/skooter500/BGE
Using GPUs to handle Big Data with Java by Adam Roberts.J On The Beach
Modern graphics processing units (GPUs) are efficient general-purpose stream processors. Learn how Java can exploit the power of GPUs to optimize high-performance enterprise and technical computing applications such as big data and analytics workloads. This presentation covers principles and considerations for GPU programming from Java and looks at the software stack and developer tools available. It also presents a demo showing GPU acceleration and discusses what is coming in the future.
syzkaller is an unsupervised, coverage-guided Linux syscall fuzzer.
The presentation covers basic of operation of the fuzzer, gives tutorial on how to run it and how to extend it to fuzz new drivers.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
SAP Sapphire 2024 - ASUG301 building better apps with SAP Fiori.pdfPeter Spielvogel
Building better applications for business users with SAP Fiori.
• What is SAP Fiori and why it matters to you
• How a better user experience drives measurable business benefits
• How to get started with SAP Fiori today
• How SAP Fiori elements accelerates application development
• How SAP Build Code includes SAP Fiori tools and other generative artificial intelligence capabilities
• How SAP Fiori paves the way for using AI in SAP apps
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Climate Impact of Software Testing at Nordic Testing DaysKari Kakkonen
My slides at Nordic Testing Days 6.6.2024
Climate impact / sustainability of software testing discussed on the talk. ICT and testing must carry their part of global responsibility to help with the climat warming. We can minimize the carbon footprint but we can also have a carbon handprint, a positive impact on the climate. Quality characteristics can be added with sustainability, and then measured continuously. Test environments can be used less, and in smaller scale and on demand. Test techniques can be used in optimizing or minimizing number of tests. Test automation can be used to speed up testing.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
Why You Should Replace Windows 11 with Nitrux Linux 3.5.0 for enhanced perfor...SOFTTECHHUB
The choice of an operating system plays a pivotal role in shaping our computing experience. For decades, Microsoft's Windows has dominated the market, offering a familiar and widely adopted platform for personal and professional use. However, as technological advancements continue to push the boundaries of innovation, alternative operating systems have emerged, challenging the status quo and offering users a fresh perspective on computing.
One such alternative that has garnered significant attention and acclaim is Nitrux Linux 3.5.0, a sleek, powerful, and user-friendly Linux distribution that promises to redefine the way we interact with our devices. With its focus on performance, security, and customization, Nitrux Linux presents a compelling case for those seeking to break free from the constraints of proprietary software and embrace the freedom and flexibility of open-source computing.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
Communications Mining Series - Zero to Hero - Session 1DianaGray10
This session provides introduction to UiPath Communication Mining, importance and platform overview. You will acquire a good understand of the phases in Communication Mining as we go over the platform with you. Topics covered:
• Communication Mining Overview
• Why is it important?
• How can it help today’s business and the benefits
• Phases in Communication Mining
• Demo on Platform overview
• Q/A
UiPath Test Automation using UiPath Test Suite series, part 5DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 5. In this session, we will cover CI/CD with devops.
Topics covered:
CI/CD with in UiPath
End-to-end overview of CI/CD pipeline with Azure devops
Speaker:
Lyndsey Byblow, Test Suite Sales Engineer @ UiPath, Inc.
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
3. spu gameplay difficulties
• multiprocessor
• NUMA
• different ISA
• it’s different
– takes time and effort to retrofit code
– unfamiliarity with the necessary upfront design
6. your code doesn’t compile
x:/core/code/users/jvalenzu/shared/igCore/igsys/igDebug.h(19,19): error:
libsn.h: No such file or directory
x:/core/code/users/jvalenzu/shared/igCore/igTime/igTimer.h(15,27): error:
sys/time_util.h: No such file or directory
pickup/pickupbase_preupdate_raw.inc(160): error: 'DEFAULT_FLAGS' is not a
member of 'COLL'
pickup/pickupbase_preupdate_raw.inc(160): error: 'EXCLUDE_HERO_ONLY' is
not a member of 'COLL'
x:/core/code/users/jvalenzu/shared/igCore/igPhysics/ppu/igPhysics.h(293):
error: expected unqualified-id before '*' token
x:/core/code/users/jvalenzu/shared/igCore/igPhysics/ppu/igPhysics.h(293):
error: expected ',' or '...' before '*' token
x:/core/code/users/jvalenzu/shared/igCore/igPhysics/ppu/igPhysics.h(293):
error: ISO C++ forbids declaration of 'parameter' with no type
x:/core/code/users/jvalenzu/shared/igCore/igg/igShaderStructs.h: At global
scope:
x:/core/code/users/jvalenzu/shared/igCore/igg/igShaderStructs.h(22):
error: redefinition of 'struct VtxVec4'
x:/core/code/users/jvalenzu/shared/igCore/igsys/igTypes.h(118): error:
previous definition of 'struct VtxVec4'
7. object driven update
for(i = 0; i < num_entities; ++i) {
entity* e = &g_entity_base[i];
e->collect_info();
e->update();
e->move();
e->animate();
e->etc();
}
• can’t amortize setup costs
• can’t hide much deferred work
8. more modular update
for(i = 0, e = &g_entity_base[0]; i < num_ent; ++i, ++e) {
e->collect_info();
e->issue_anim_request();
}
for(i = 0, e = &g_entity_base[0]; i < num_ent; ++i, ++e)
e->update();
finalize_animation();
for(i = 0, e = &g_entity_base[0]; i < num_ent; ++i, ++e)
e->postupdate();
1
2
9. aggregate updating
• group instances by type
– further sort each group to minimize state
change
• one aggregate updater per type, with
multiple code fragments
• combined ppu & spu update
• more opportunity to amortize cost of
expensive setup
18. overview
• AsyncMobyUpdate
– base framework, meant to work with update
classes
– retains MobyInstance rendering pipeline
• Guppys
– “light” MobyInstance replacement
– 100% SPU update, no update class
– 90% MobyInstance rendering pipeline
• AsyncEffect
– very easy fire & forget SPU “effects”
– user-selectable, not user-written, shaders
19. async moby update
• designed to move update classes to SPU
• user supplied update routine in code
fragment
• multiple code fragments per update class
–one per AI state, for example
• user-defined instance data format
• user-defined common data
• extern code provided through function
pointer tables
20. async moby update (cont...)
InstancesUpdate Groups
0x0128020
0x012C050
0x011F070
jet_follow_path
0x0128020
0x012C050
0x011F070
jet_circle
jet_crash
• update group per code fragment
• instances bound to update group each frame
21. instance vs common
• instance data
– data transformed by your update routine
– e.g. a Jet, or zombie limb
• common data
– data common to all instances of the same
type
– e.g. class-static variables, current frame
29. our gameplay shaders
• 32k relocatable programs
• makefile driven process combines code,
data into fragment
• instance types
– user defined (Async Moby Update)
– predefined (Guppys, AsyncEffect)
30. more shader talk
• What do our code fragments do?
– dma up instances
– transform instance state, position
– maybe set some global state
– dma down instances
• typical gameplay stuff
– preupdate, update, postupdate
31. more about instance data
• what is our instance data?
– not an object
– generally, a subset of an update class
– different visibility across PU/SPU
• where does instance data live?
– could be copied into a separate array
– could read directly from the update classes
– we support and use both forms
33. data inside update class
• advantages
–pay memory cost as you go
–don’t need to know about every detail of
an update class
• disadvantages
–no longer control “lifetime” of objects
• specify interesting data with stride/offset
34. instance prefetch problem
Instance pipe[2];
dma_get(&pipe[0], ea_base, sizeof(Instance), tag);
for(int i = 0; i < num_instances; ++i) {
Instance* cur_inst = &pipe[i&1];
Instance* next_inst = &pipe[(i+1)&1];
dma_sync(tag);
dma_get(next_inst, ea_base + (i+1) * sizeof(Instance), tag);
// ... do work
}
• ea_base = starting address of our instances
• num_instances = number of instances
35. instance prefetch problem (cont)
Instance pipe[2];
dma_get(&pipe[0], ea_base, sizeof(Instance), tag);
for(int i = 0; i < num_instances; ++i) {
Instance* cur_inst = &pipe[i&1];
Instance* next_inst = &pipe[(i+1)&1];
dma_sync(tag);
dma_get(next_inst, ea_base + (i+1) * sizeof(Instance), tag);
MobyInstance cur_moby;
dma_get(&cur_moby, cur_inst->m_moby_ea, sizeof(MobyInstance), tag);
dma_sync(tag);
// do work
}
• ... we almost always need to fetch an associated data
member out of our instances immediately
36. instance “streams”
• instances are available as “streams”
–each has its own base, count, offset,
stride, and addressing mode
• allows one to prefetch multiple associated
elements without stalling
• also useful for getting slices of interesting
data out of an untyped blob
40. memory addressing
• direct
–contiguous block of instances
• direct indexed
–indices used to deference an array of
instances
• indirect indexed
–indices used to source an array of
instance pointers
41. More Memory Addressing
• common blocks are preloaded
• shaders must DMA up their own instances
• meta-information is preloaded
–indices
–EA base pointer (direct)
–EA pointer array (indirect)
• buffering logic is very context sensitive
42. indirect indexed example
struct DroneInfo
{
u32 m_stuff;
};
class DroneUpdate : public AI::Component
{
// …
DroneInfo m_info;
MobyInstance* m_moby;
};
51. extern "C" void
async_foo_update(global_funcs_t* gt,
update_set_info_t* info,
common_blocks_t* common_blocks,
instance_streams_t* instance_streams,
u8* work_buffer, u32 buf_size, u32 tags[4])
• global_funcs_t - global function pointer table
• update_set_info_t - meta info
• common blocks_t - stream array for common blocks
• instance_streams_t - stream array for instances
• work_buffer & buf_size - access to LS
• dma_tags - 4 preallocated dma tags
code fragment signature
52. guppys
• lightweight alternative to MobyInstance
• update runs entirely on SPU
• one 128byte instance type
• common data contained in “schools”
• simplified rendering
53. guppys
• to cleave a mesh, we previously
required an entire new
MobyInstance to cleave a mesh
– turn off arm mesh segment on
main instance
– turn off all other mesh segments
on spawned instance
• spawn a guppy now instead
• common use case:
“bangles”
54. the guppy instance
• position/orientation EA
• 1 word flags
• block of “misc” float/int union data
• animation joints EA
• joint remap table
• Insomniac “special sauce”
55. Async Effect
• simplified API for launching SPU-updating
effects
• no code fragment writing necessary
• specialized at initialization
– linear/angular movement
– rigid body physics
– rendering parameters
56. Async Effect API
u16 moby_iclass = LookupMobyClassIndex( ART_CLASS_BOT_HYBRID_2_ORGANS );
MobyClass* mclass = &IGG::g_MobyCon.m_classes[ moby_iclass ];
u32 slot = AsyncEffect::BeginEffectInstance(AsyncEffect::EFFECT_STATIONARY,
mclass);
AsyncEffect::SetEffectInstancePo (slot, moby->m_mat3, moby->m_pos);
AsyncEffect::SetEffectInstanceF32(slot, AsyncEffect::EFFECT_PARAM_LIFESPAN,
20.0f);
u32 name = AsyncEffect::Spawn(slot);
• stationary effect with 20 second life
• name can be used to kill the effect
58. • immediate
– via global function table
• deferred
– command buffer
• adhoc
– PPU shims
– direct data injection
different mechanisms
59. deferred
• PPU shims
– flags set in SPU update, querys/events
triggered subsequently on PPU
• command buffer
– small buffer in LS filled with command specific
byte-code, flushed to PPU
• atomic allocators
– relevant data structures packed on SPU,
atomically inserted
61. command buffer: results
frame n
frame n+1
handle_base = ((stage << 5) | (job_number & 0x1f)) << 24;
// …
handle = handle_base + request++;
frame n, stage 0, job 1
frame n, stage 1, job 1
frame n, stage 2, job 1
frame n, stage 0, job 2
offset table
result
62. direct data
• patch into atomically allocated, double
buffered data structures
• instance allocates fresh instance each
frame, forwards state between old and
new
• deallocation == stop code fragment
• used for rigid body physics
63. direct data
SPU main memory
new_ea = rigid body #0
rigid body #0
rigid body #1
rigid body #2
unallocated
get(&ls_rigidbody, old_ea)
update ls_rigidbody
old_ea = new_ea
put(&ls_rigidbody, new_ea)
1
2
3
64. SPU API
• SPU-API
– mechanism to expose new functionality
through to the AsyncMobyUpdate system
– library of code fragment code and common
data (“fixup”)
– function pointer table (“interface”) oriented
– hides immediate or deferred commands
66. example #1
• Jets
– uses AsyncMobyUpdate along with an Update Class
– packed instance array
– code fragment per AI state
– little initialization setup, state changes rare
– events triggered using adhoc method
• flags checked at pack/unpack time
• inputs:
– position/orientation
– state info
• output:
– position/orientation
67. example #2
• zombie limbs
– guppy
– not much update logic
– direct data interface to rigid body physics
• input:
– position/orientation
– animation joints
– collision info
• output:
– packed rigid bodies
69. porting code sucks
• difficult to retrofit code
• different set of constraints
• expensive use of time
• can result in over-abstracted systems
– like, software cache for transparent pointers
70. couple of tips
struct foo_t : bar_t
{
// stuff
u32 m_first;
u32 m_second;
u32 m_third;
u32 m_fourth;
// more stuff
};
Separate interesting information from non-necessary data structures
struct foo_info_t
{
u32 m_first;
u32 m_second;
u32 m_third;
u32 m_fourth;
};
struct foo_t : bar_t
{
// stuff
foo_info_t m_info;
// more stuff
};
72. living with polymorphism
• the described mechanisms have problems
with virtual functions
– would need to port and patch up all possible
vtable destinations
– would end up duplicating/shadowing virtual
class hierarchy on SPU
• could work, but we don’t do that
73. compile-time polymorphism
• do a trace of the class hierarchy: one code
fragment per leaf class
• separate base functions into .inc files
• virtual functions selected through sequential
macro define/undef pairs
• not described:
– deferred resolution of base function calls to
derived function via preprocessor pass
77. design from scratch
• parameterized systems
– not specialized by code
• use atomic allocators as programming
interfaces
• no virtual functions in update phase
• separate perception, cognition, action
• plan to interleave ppu/spu
78. In conclusion
• design up front for deferred, SPU-friendly
systems.
• don’t worry too much about writing optimized
code, just make it difficult to write unoptimizable
code
• remember, this is supposed to be fun. SPU
programming is fun.
79. all pictures U.S. Fish & Wildlife Service except
The Whale Fishery - NOAA National Marine Fisheries Service
jurvetson@flickr “Swarm Intelligence” photo
Thanks
joe@insomniacgames.com